//This function outputs text to the screen of a specified font
void dizPrint(DIZ_FONT *font, const char *format, ...) {
//Declare a buffer for our output text
char text[256];
//Declare a handle for our argument list
va_list argList;
//Double-check that we have an actual string to output
if (format == NULL) {
return;
}
//Start up our variable argument functions
va_start(argList, format);
//Use our argument list to format our string into our text[] array
vsprintf_s(text, sizeof(text), format, argList);
va_end(argList);
//Push out our List attribute to prevent it interfering with anything else
glPushAttrib(GL_LIST_BIT);
//Check what type of font we're using
if (font->info.type == DIZ_FONT_BITMAP) {
//If it's a Bitmap, we account for the 32 skipped characters
glListBase(font->base - 32);
}else if (font->info.type == DIZ_FONT_OUTLINE) {
//Otherwise we just set it to the normal base value for Outlines
glListBase(font->base);
}
//Call the lists to output our text
glCallLists(strlen(text), GL_UNSIGNED_BYTE, text);
//Pop our List attribute back into place
glPopAttrib();
}
void call(LISTS const& _lists) const
{
if (_lists.empty()) return;
glListBase(id_);
glCallLists(_lists.size(), type_id<typename LISTS::value_type>(),_lists.data());
glListBase(0);
}
void glprint(int x, int y, string glstring){
glBindTexture(GL_TEXTURE_2D, Font);
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, ww, wh, 0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glColor4f(0.5, 0.5, 0.5, a);
glTranslated(x + 1, y + 1, 0);
glListBase(gbe);
glCallLists((GLsizei)glstring.length(), GL_UNSIGNED_BYTE, glstring.c_str());
glLoadIdentity();
glColor4f(r, g, b, a);
glTranslated(x, y, 0);
glListBase(gbe);
glCallLists((GLsizei)glstring.length(), GL_UNSIGNED_BYTE, glstring.c_str());
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glEnable(GL_DEPTH_TEST);
glColor4f(1.0, 1.0, 1.0, 1.0);
}
/**
* Output text onto the GUI
*/
GLfloat textPrintf(const char *fmt, ...)
{
unsigned int i;
GLfloat length = 0;
char text[256] = { 0 };
va_list ap;
if (fmt == NULL)
return (-1);
va_start(ap, fmt);
vsprintf(text, fmt, ap);
va_end(ap);
for (i = 0; i < strlen(text); i++)
length += gmf[(int) text[i]].gmfCellIncX;
glPushMatrix();
glScalef(textWidth, textHeight, 0);
/* Translate for alignment */
switch (alignment)
{
case ALIGN_RIGHT: {
glTranslatef(-length, 0.0, 0.0);
break;
}
case ALIGN_CENTER: {
glTranslatef(-length / 2, 0.0, 0.0);
break;
}
case ALIGN_LEFT:
default: {
break;
}
}
glPushAttrib(GL_LIST_BIT);
glPushMatrix();
glListBase(base);
glCallLists(strlen(text), GL_UNSIGNED_BYTE, text);
glPopMatrix();
if (textWidth != TEXT_LARGE)
glLineWidth(LINE_WIDTH_SMALL);
glPushMatrix();
glListBase(baseOut);
glCallLists(strlen(text), GL_UNSIGNED_BYTE, text);
glPopMatrix();
glLineWidth(LINE_WIDTH);
glPopAttrib();
glPopMatrix();
return (length);
}
void CMy3D_view_FPbody_modelView::DrawCoordinate()
{
// Clear the window with current clearing color
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
glTranslatef(-DrawSpaceSize + 0.5f, -DrawSpaceSize + 0.8f, 0.0f);
glRotatef(-45+OPRT->Get_xRot(), 0.0f, 1.0f, 0.0f);
glRotatef(-45+OPRT->Get_yRot(), 1.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Set current drawing color to red
// R G B
glColor3f(0.0, 0.0, 0.0);
glLineWidth(2.5);
glBegin(GL_LINES);
glVertex3f(0.0f,0.0f,0.0f);
glVertex3f(DrawSpaceSize*0.2f,0.0f,0.0f);
glEnd();
glBegin(GL_LINES);
glVertex3f(0.0f,0.0f,0.0f);
glVertex3f(0.0f,DrawSpaceSize*0.2,0.0f);
glEnd();
glBegin(GL_LINES);
glVertex3f(0.0f,0.0f,0.0f);
glVertex3f(0.0f,0.0f,DrawSpaceSize*0.2f);
glEnd();
glLineWidth(1.0);
glTranslatef(0.30f, 0.30f, 0.30f);
glutWireCube(0.6);
glRasterPos3f(DrawSpaceSize*0.2f, 0.0f-0.3f, 0.0f-0.3f);
glListBase(m_2DTextList);
glCallLists(1, GL_UNSIGNED_BYTE ,"x");
glRasterPos3f(0.0f-0.3, DrawSpaceSize*0.2f-0.2f, 0.0f-0.3f);
glListBase(m_2DTextList);
glCallLists(1, GL_UNSIGNED_BYTE ,"y");
glRasterPos3f(0.0f-0.3, 0.0f-0.3f, DrawSpaceSize*0.2f);
glListBase(m_2DTextList);
glCallLists(1, GL_UNSIGNED_BYTE ,"z");
glPopMatrix();
glLoadIdentity();
}
void glfntWriteBitmap(float x,float y,char *s)
{
GLint CurBase;
if (LettersDL==0) return;
glRasterPos2f(x,y);
glGetIntegerv(GL_LIST_BASE,&CurBase);
glListBase(LettersDL);
glCallLists(strlen(s),GL_UNSIGNED_BYTE,s);
glListBase(CurBase);
}
void BitmapFont::draw( const std::string& text ) const
{
const GLuint lists = _gl.getList( _key );
LBASSERTINFO( lists != ObjectManager::INVALID,
"Font not initialized" );
if( lists != ObjectManager::INVALID )
{
glListBase( lists );
glCallLists( GLsizei( text.size( )), GL_UNSIGNED_BYTE, text.c_str( ));
glListBase( 0 );
}
}
void handler_src_dst_ip_render_2d_scene(void)
{
guint i;
GLfloat unit_size = CUBE_SIZE / (GLfloat) (viz->src_bound.max_x_coord - viz->src_bound.min_x_coord);
// draw a square outline
glCallList(GREY_2D_SQUARE_CALL_LIST);
// draw a white square representing each range over our grey base
for (i = 0; i < viz->num_src_ranges; ++i) {
GLfloat x_coord = (GLfloat) ((viz->src_ranges[i].x_coord - viz->src_bound.min_x_coord) * unit_size) - 1.0;
GLfloat y_coord = (GLfloat) ((viz->src_ranges[i].y_coord - viz->src_bound.min_y_coord) * unit_size) - 1.0;
GLfloat width = (GLfloat) (viz->src_ranges[i].width * unit_size);
glBegin(GL_QUAD_STRIP);
glNormal3f(0.0, 0.0, 1.0);
glColor3ub(255, 255, 255);
glVertex2f(x_coord, y_coord);
glVertex2f(x_coord, y_coord + width);
glVertex2f(x_coord + width, y_coord);
glVertex2f(x_coord + width, y_coord + width);
glEnd();
}
// derive address based on the quadtree coordinates of our bounding box
struct in_addr low_addr;
struct in_addr high_addr;
range_reverse_quadtree(&viz->src_bound, &low_addr, &high_addr);
gchar *low_str = g_strdup_printf(" %s", inet_ntoa(low_addr));
gchar *high_str = g_strdup_printf(" %s", inet_ntoa(high_addr));
// lower address range label
glColor3f(1.0, 1.0, 1.0);
glRasterPos2f(-1.0, -1.0);
glListBase(viz->font_list_2d);
glCallLists(strlen(low_str), GL_UNSIGNED_BYTE, low_str);
// higher address range label
glRasterPos2f(1.0, 1.0);
glListBase(viz->font_list_2d);
glCallLists(strlen(high_str), GL_UNSIGNED_BYTE, high_str);
g_free(low_str);
g_free(high_str);
// render all our nodes!
g_tree_foreach(viz->nodes, handler_src_dst_ip_render_2d_node, NULL);
}
void renderASCIIString(int x, int y, string glstring) {
//glBindTexture(GL_TEXTURE_2D, Font);
glPushMatrix();
glLoadIdentity();
glColor4f(0.5, 0.5, 0.5, a);
glTranslated(x + 1, y + 1, 0);
glListBase(gbe);
glCallLists((GLsizei)glstring.length(), GL_UNSIGNED_BYTE, glstring.c_str());
glLoadIdentity();
glColor4f(r, g, b, a);
glTranslated(x, y, 0);
glListBase(gbe);
glCallLists((GLsizei)glstring.length(), GL_UNSIGNED_BYTE, glstring.c_str());
glPopMatrix();
}
void printString(char * s)
{
glPushAttrib(GL_LIST_BIT);
glListBase(fontOffset);
glCallLists(strlen(s), GL_UNSIGNED_BYTE, (GLubyte *) s);
glPopAttrib();
}
//--------------------------------------------------------------
// Name: CGL_APP::Print - public
// Description: Print a string onto the screen
// Arguments: -iX, iY: Position on the screen to start printing
// -vecColor: The color of the printed text
// -szString: the string to be printed
// Return Value: None
//--------------------------------------------------------------
void CGL_APP::Print( int iX, int iY, CVECTOR vecColor, char* szString, ... )
{
va_list va;
char szParsedString[256];
//make sure that the string actually exists
if( szString==NULL )
return;
//parse the string
va_start( va, szString );
vsprintf( szParsedString, szString, va );
va_end( va );
//set the color for the text
glColor3f( vecColor[0], vecColor[1], vecColor[2] );
glPushMatrix( );
glLoadIdentity( );
//position and render the text
glRasterPos2d( iX, iY );
glListBase( m_uiFont );
glCallLists( strlen( szParsedString ), GL_UNSIGNED_BYTE, szParsedString );
glPopMatrix( );
}
GLvoid glPrint(GLint x, GLint y, int set, const char *fmt, ...) // Where The Printing Happens
{
char text[256]; // Holds Our String
va_list ap; // Pointer To List Of Arguments
if (fmt == NULL) // If There's No Text
return; // Do Nothing
va_start(ap, fmt); // Parses The String For Variables
vsprintf(text, fmt, ap); // And Converts Symbols To Actual Numbers
va_end(ap); // Results Are Stored In Text
if (set>1) // Did User Choose An Invalid Character Set?
{
set=1; // If So, Select Set 1 (Italic)
}
glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
glLoadIdentity(); // Reset The Modelview Matrix
glTranslated(x,y,0); // Position The Text (0,0 - Bottom Left)
glListBase(base-32+(128*set)); // Choose The Font Set (0 or 1)
if (set==0) // If Set 0 Is Being Used Enlarge Font
{
glScalef(1.5f,2.0f,1.0f); // Enlarge Font Width And Height
}
glCallLists(strlen(text),GL_UNSIGNED_BYTE, text); // Write The Text To The Screen
glDisable(GL_TEXTURE_2D); // Disable Texture Mapping
}
void CFont::printSubString(float xPosition, float yPosition,
float width, float height,
float r, float g, float b,
int start, int end,
const String &string)
{
if (start >= end)
return;
int stringLength = string.getLength();
if (stringLength < end)
return;
glColor3f(r,g,b);
fontTexture.activate();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(xPosition, yPosition, 0);
glListBase(fontBaseRange);
glScalef(width, height,1.0f);
glCallLists(end - start,GL_UNSIGNED_BYTE, string + start);
glPopMatrix();
glDisable(GL_BLEND);
fontTexture.deactivate();
glColor3f(1,1,1);
}
GLvoid glPrint(const char *fmt, ...) // Custom GL "Print" Routine
{
float length=0; // Used To Find The Length Of The Text
char text[256]; // Holds Our String
va_list ap; // Pointer To List Of Arguments
if (fmt == NULL) // If There's No Text
return; // Do Nothing
va_start(ap, fmt); // Parses The String For Variables
vsprintf(text, fmt, ap); // And Converts Symbols To Actual Numbers
va_end(ap); // Results Are Stored In Text
for (unsigned int loop=0; loop<strlen(text); loop++) // Loop To Find Text Length
{
length+=gmf[text[loop]].gmfCellIncX; // Increase Length By Each Characters Width
}
glTranslatef(-length/2,0.0f,0.0f); // Center Our Text On The Screen
glPushAttrib(GL_LIST_BIT); // Pushes The Display List Bits
glListBase(base); // Sets The Base Character to 0
glCallLists(strlen(text), GL_UNSIGNED_BYTE, text); // Draws The Display List Text
glPopAttrib(); // Pops The Display List Bits
}
int main(void)
{
int menu;
FsOpenWindow(32, 32, winWidth, winHeight, 1); // 800x600 pixels, useDoubleBuffer=1
int listBase;
listBase=glGenLists(256);
YsGlUseFontBitmap8x12(listBase);
glListBase(listBase);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glDepthFunc(GL_ALWAYS);
while(1)
{
menu=Menu();
if(menu==1)
{
int score;
score=Game();
GameOver(score);
}
else if(menu==eStop)
{
break;
}
}
return 0;
}
/* Print our GL text to the screen */
GLvoid glPrint( GLfloat cnt1, GLfloat cnt2, const char *fmt, ... )
{
char text[256]; /* Holds our string */
va_list ap; /* Pointer to our list of elements */
/* If there's no text, do nothing */
if ( fmt == NULL )
return;
/* Position The Text On The Screen */
glRasterPos2f( cnt1, cnt2 );
/* Parses The String For Variables */
va_start( ap, fmt );
/* Converts Symbols To Actual Numbers */
vsprintf( text, fmt, ap );
va_end( ap );
/* Pushes the Display List Bits */
glPushAttrib( GL_LIST_BIT );
/* Sets base character to 32 */
glListBase( base - 32 );
/* Draws the text */
glCallLists( strlen( text ), GL_UNSIGNED_BYTE, text );
/* Pops the Display List Bits */
glPopAttrib( );
}
//---------------------------------------------------------------------------
void CCoordSys::Draw(CVec color)
//---------------------------------------------------------------------------
{
//draw coordinate system axes
glBegin(GL_LINES);
glColor3d(color.x,color.y,color.z);
glVertex3d(m_vecOrg);
glVertex3d(m_vecOrg+m_vecDirX);
glVertex3d(m_vecOrg);
glVertex3d(m_vecOrg+m_vecDirY);
glVertex3d(m_vecOrg);
glVertex3d(m_vecOrg+m_vecDirZ);
glEnd();
glListBase(1000);
glColor3d(0,1,1);
glRasterPos3d(m_vecOrg+m_vecDirX);
glCallLists(1, GL_UNSIGNED_BYTE, "x");
glRasterPos3d(m_vecOrg+m_vecDirY);
glCallLists(1, GL_UNSIGNED_BYTE, "y");
glRasterPos3d(m_vecOrg+m_vecDirZ);
glCallLists(1, GL_UNSIGNED_BYTE, "z");
m_vecOrg.DrawMarker();
}
void glPrints(int x, int y, int winW,int winH,char *string) // Where The Printing Happens
{
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA );
glBindTexture(GL_TEXTURE_2D, AsciiFontTexId); // Select Our Font Texture
glDisable(GL_DEPTH_TEST); // Disables Depth Testing
glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
glPushMatrix(); // Store The Projection Matrix
glLoadIdentity(); // Reset The Projection Matrix
glOrtho(0,winW,0,winH,-1,1); // Set Up An Ortho Screen
glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
glPushMatrix(); // Store The Modelview Matrix
glLoadIdentity(); // Reset The Modelview Matrix
glTranslated(x,y,0); // Position The Text (0,0 - Bottom Left)
glListBase(base-32); // Choose The Font Set (0 or 1)
glCallLists(strlen(string),GL_UNSIGNED_BYTE,string);// Write The Text To The Screen
glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
glPopMatrix(); // Restore The Old Projection Matrix
glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
glPopMatrix(); // Restore The Old Projection Matrix
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
}
void BFont::print(float x, float y, const char* string)
{
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0,0,400,400,0,1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRasterPos2f(x,y);
glListBase(this->m_listBase-32);
glCallLists(strlen(string),GL_UNSIGNED_BYTE,string);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glEnable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
}
void RasterFont::printString(const char *s, double x, double y, double z)
{
int length = (int)strlen(s);
if (!length)
return;
if (length >= TEMP_BUFFER_SIZE)
length = TEMP_BUFFER_SIZE - 1;
// Sanitize string to avoid GL errors.
char *s2 = temp_buffer;
memcpy(s2, s, length);
s2[length] = 0;
for (int i = 0; i < length; i++)
{
if (s2[i] < 32 || s2[i] > 126)
s2[i] = '!';
}
// go to the right spot
glRasterPos3d(x, y, z);
glPushAttrib (GL_LIST_BIT);
glListBase(fontOffset);
glCallLists((GLsizei)strlen(s2), GL_UNSIGNED_BYTE, (GLubyte *) s2);
glPopAttrib();
}
//------------------------------------------------------------------------------
// outputText() -- Text output routines
//------------------------------------------------------------------------------
void BitmapFont::outputText(const double x, const double y, const char* txt, const int n, const bool vf, const bool)
{
// Make sure we have characters to print
if (n <= 0) return;
// Make sure we have a loaded font
if (isNotLoaded()) {
loadFont();
if (isNotLoaded()) throw new ExpInvalidFont();
}
// Prepare the output text
char cbuf[MSG_BUF_LEN];
int nn = xferChars(cbuf,MSG_BUF_LEN,txt,n);
if (nn <= 0) return;
// Set the base
glListBase(getBase());
// output the text
if (vf) {
// Vertical text
for (int i = 0; i < nn; i++) {
glRasterPos2d( x, (y - float(i)*getLineSpacing()) );
glCallLists(1, GL_UNSIGNED_BYTE, &cbuf[i]);
}
}
else {
// Normal text
glRasterPos2d(x,y);
glCallLists(nn, GL_UNSIGNED_BYTE, cbuf);
}
}
static void redraw( Display *dpy, Window w )
{
static const char *text = " Rotated bitmap text";
int i;
glClear( GL_COLOR_BUFFER_BIT );
/* triangle */
glColor3f( 0.2, 0.2, 1.0 );
glBegin(GL_TRIANGLES);
glVertex2f( -0.8, 0.7 );
glVertex2f( -0.8, -0.7 );
glVertex2f( 0.8, 0.0 );
glEnd();
/* marker */
glColor3f( 0, 1, 0 );
glBegin(GL_POINTS);
glVertex2f(0, 0);
glEnd();
/* text */
glColor3f( 1, 1, 1 );
for (i = 0; i < 4; i++) {
glRasterPos2f(0, 0);
glListBase(FontBase[i]);
glCallLists(strlen(text), GL_UNSIGNED_BYTE, (GLubyte *) text);
}
glXSwapBuffers( dpy, w );
}
void GLText::PrintString( const float p_X, const float p_Y,
const std::string &p_String, ... )
{
char Text[ 512 ] = { '\0' };
char StringCopy[ 512 ] = { '\0' };
va_list ListPointer;
if( p_String.size( ) == 0 )
{
return;
}
strncpy( StringCopy, p_String.c_str( ), p_String.size( ) );
va_start( ListPointer, StringCopy );
vsprintf( Text, p_String.c_str( ), ListPointer );
va_end( ListPointer );
glMatrixMode( GL_PROJECTION );
glLoadIdentity( );
glOrtho( 0, m_ScreenWidth, m_ScreenHeight, 0, 0, 1 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );
glTranslatef( 0.0f, 0.0f, -1.0f );
glColor4f( m_Red, m_Green, m_Blue, m_Alpha );
glRasterPos2f( p_X, p_Y );
glPushAttrib( GL_LIST_BIT );
glListBase( m_FontBase - 32 );
glCallLists( p_String.size( ), GL_UNSIGNED_BYTE, Text );
glPopAttrib( );
}
void glfemDrawMessage(int h, int v, char *s)
{
// Les coordonnées négatives sont normalement admises :-)
// On conserve le strint entier même si le début est off-screen
int off;
glPushAttrib(GL_ALL_ATTRIB_BITS);
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho (0.0, gRasterH, gRasterV, 0.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
if (h < 0) h = gRasterH + h - strlen(s)*10;
if (v < 0) v = gRasterV + v;
glRasterPos2i(h, v);
glListBase(fontOffset);
if (h >= 0) {
glRasterPos2i(h, v);
glCallLists((GLsizei) strlen(s), GL_UNSIGNED_BYTE, (GLubyte *) s); }
else {
off = (h-9)/10;
glRasterPos2i(h - off*10, v);
if (strlen(s)+off > 0) glCallLists((GLsizei) strlen(s)+off, GL_UNSIGNED_BYTE, (GLubyte *) &s[-off]); }
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopAttrib ();
}
void print_text(const char* string) {
if(string==NULL) return;
glPushAttrib(GL_LIST_BIT);
glListBase(listBase);
glCallLists((GLsizei)strlen(string), GL_UNSIGNED_BYTE, string);
glPopAttrib();
}
GLvoid glPrint(GLint x, GLint y, const char *fmt, ...) // Custom GL "Print" Routine
{
/*
float length=0; // Used To Find The Length Of The Text
char text[256]; // Holds Our String
va_list ap; // Pointer To List Of Arguments
if (fmt == NULL) // If There's No Text
return; // Do Nothing
va_start(ap, fmt); // Parses The String For Variables
vsprintf_s(text, fmt, ap); // And Converts Symbols To Actual Numbers
va_end(ap); // Results Are Stored In Text
for (unsigned int loop=0;loop<(strlen(text));loop++) // Loop To Find Text Length
{
length+=gmf[text[loop]].gmfCellIncX; // Increase Length By Each Characters Width
}
glTranslatef(x,y,0.0f); // Center Our Text On The Screen
glPushAttrib(GL_LIST_BIT); // Pushes The Display List Bits
glListBase(base); // Sets The Base Character to 0
glCallLists(strlen(text), GL_UNSIGNED_BYTE, text); // Draws The Display List Text
glPopAttrib();
*/
// Pops The Display List Bits
char text[256]; // Holds Our String
va_list ap; // Pointer To List Of Arguments
if (fmt == NULL) // If There's No Text
return; // Do Nothing
va_start(ap, fmt); // Parses The String For Variables
vsprintf(text, fmt, ap); // And Converts Symbols To Actual Numbers
va_end(ap); // Results Are Stored In Text
RECT window; // Storage For Window Dimensions
GetClientRect (g_window->hWnd,&window); // Get Window Dimensions
glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
glDisable(GL_LIGHTING);
glPushMatrix(); // Store The Projection Matrix
glLoadIdentity(); // Reset The Projection Matrix
glOrtho(0,window.right,0,window.bottom,0,1); // Set Up An Ortho Screen
//////////////////////////////////////////
glTranslatef((GLfloat)x,(GLfloat)(window_height-y),-0.1f);
glPushAttrib(GL_LIST_BIT); // Pushes The Display List Bits
glListBase(base - 32); // Sets The Base Character to 32
glPushMatrix();
glRasterPos2f(0.1f,0.1f);
//glTranslatef(x,y,-1.0f);
glCallLists(strlen(text), GL_UNSIGNED_BYTE, text); // Draws The Display List Text
glPopMatrix();
glPopAttrib(); // Pops The Display List Bits
/////////////////////////////////////////
glEnable(GL_LIGHTING);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
void GUIWindow::PrintString(std::string str)
{
const char *ch;
ch = str.c_str();
glListBase(base);
glCallLists(strlen(ch), GL_UNSIGNED_BYTE, (GLubyte *)ch);
}
void GUI_Laftfont::printgl(int x, int y, int z, const wchar_t *fmt, ...)
{
wchar_t text[2048];
va_list ap;
size_t str_len;
if ((!listsFont) || (!fmt)) return;
va_start(ap, fmt);
#ifdef WIN32
_vsnwprintf(text, 2048, fmt, ap);
#else
vswprintf(text, 2048, fmt, ap);
#endif
va_end(ap);
str_len = wcslen(text);
// should be in modelview mode
glPushMatrix();
glLoadIdentity();
glEnable(GL_TEXTURE_2D);
glListBase(listsFont);
glTranslatef((float)x, (float)y, (float)z);
glScalef(1.0f, -1.0f, 1.0f);
#ifdef WIN32
glCallLists((GLsizei)(str_len), GL_UNSIGNED_SHORT, text);
#else
glCallLists((GLsizei)(str_len), GL_UNSIGNED_INT, text);
#endif
glDisable(GL_TEXTURE_2D);
glPopMatrix();
return;
}
GLvoid nehewidget::glPrint(GLint x, GLint y, int set, const char *fmt, ...)
{
char text[256];
va_list ap;
if (fmt == NULL)
return;
va_start(ap, fmt);
vsprintf(text, fmt, ap);
va_end(ap);
if (set>1)
{
set=1;
}
glEnable(GL_TEXTURE_2D);
glLoadIdentity();
glTranslated(x,y,0);
glListBase(base-32+(128*set));
if (set==0)
{
glScalef(1.5f,2.0f,1.0f);
}
glCallLists(strlen(text),GL_UNSIGNED_BYTE, text);
glDisable(GL_TEXTURE_2D);
}
void GUI_Laftfont::printgl(int x, int y, int z, const char *fmt, ...)
{
char text[2048];
va_list ap;
size_t str_len;
if ((!listsFont) || (!fmt)) return;
va_start(ap, fmt);
vsnprintf(text, 2048, fmt, ap);
va_end(ap);
str_len = strlen(text);
// should be in modelview mode
glPushMatrix();
glLoadIdentity();
glEnable(GL_TEXTURE_2D);
glListBase(listsFont);
glTranslatef((float)x, (float)y, (float)z);
glScalef(1.0f, -1.0f, 1.0f);
glCallLists((GLsizei)(str_len), GL_BYTE, text);
glDisable(GL_TEXTURE_2D);
glPopMatrix();
return;
}
