void draw_score(long long int score)
{
long long int tempsc = score;
char str[15];
sprintf(str,"%lld",tempsc);
glutStrokeString(GLUT_STROKE_ROMAN,"SCORE : ");
glutStrokeString(GLUT_STROKE_ROMAN,str);
}
void RenderGroupCount(int count, int offset){
// convert to expected format
std::string c = std::to_string(count);
const unsigned char * d = (const unsigned char*)c.c_str();
glutStrokeString(GLUT_STROKE_ROMAN, d);
}
//Display words on screen
void DisplayInstructions()
{
if (window.handle == -1)
return;
vector<string> * s = &window.instructions;
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glColor3f(0.0f, 0.0f, 0.0f);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, window.size.x, 0, window.size.y, 1, 10);
glViewport(0, 0, window.size.x, window.size.y);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslated(window.size.x - 450, 19 * s->size(), -5.5);
glScaled(0.14, 0.14, 1.0);
glLineWidth(3.0f);
for (auto i = s->begin(); i < s->end(); ++i)
{
glPushMatrix();
glutStrokeString(GLUT_STROKE_MONO_ROMAN, (const unsigned char *) (*i).c_str());
glPopMatrix();
glTranslated(0, -150, 0);
}
glLineWidth(1.0f);
}
static void drawTextOnScreen(int x, int y, const char* string, float* color, void* font, float scaleX, float scaleY) {
glDisable(GL_LIGHTING);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glMatrixMode( GL_MODELVIEW );
glPushMatrix();
glLoadIdentity();
glMatrixMode( GL_PROJECTION );
glPushMatrix();
glLoadIdentity();
glColor4fv(color);
gluOrtho2D( 0, glutGet(GLUT_WINDOW_WIDTH), 0, glutGet(GLUT_WINDOW_HEIGHT) );
glTranslatef(x, y, 0);
//glRasterPos2i( x, y );
glScalef(scaleX, scaleY, 1);
glutStrokeString(font, (UCHAR*)string);
//glutBitmapString(font, (UCHAR*)string);
glPopMatrix();
glMatrixMode( GL_MODELVIEW );
glPopMatrix();
glDisable(GL_BLEND);
glEnable(GL_LIGHTING);
}
/******************************************************************************
* Function: showPausedStr()
* Authors: Ian Carlson, Christopher Smith
* Description: Displays that the game is paused when paused
* ****************************************************************************/
void showPausedStr()
{
glColor3f(1,1,1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef( 350, 100, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"***PAUSED***" );
glPopMatrix();
}
void XSADrawString(d_XSA3DPoint translate,float rotation,double scale,const unsigned char* string) {
int length = glutStrokeLength(GLUT_STROKE_MONO_ROMAN, string);
glPushMatrix();
glTranslated(translate.x, translate.y, translate.z);
glScaled(scale, scale, scale);
glRotatef(-rotation, 0.0, 1.0, 0.0);
glTranslated(-(length / 2), 0.0, 0.0);
glutStrokeString(GLUT_STROKE_MONO_ROMAN, string);
glPopMatrix();
}
void XSADrawStringHUD(d_XSA3DPoint point,float rotation,const unsigned char* buf) {
int length = glutStrokeLength(GLUT_STROKE_MONO_ROMAN, buf);
glColor3f(0.0, 1.0, 0.0); // green
glPushMatrix();
glTranslated(point.x, point.y, point.z);
glRotatef(-rotation, 0.0, 1.0, 0.0);
glTranslated(0.0, 0.1, -10.0);
glScaled(0.001, 0.001, 0.001);
glTranslated(-(length / 2), 0.0, 0.0);
glutStrokeString(GLUT_STROKE_MONO_ROMAN, buf);
glPopMatrix();
}
/******************************************************************************
* Function: draw_scores()
* Authors: Ian Carlson, Christopher Smith
* Description: Displays the scores to the screen
* ****************************************************************************/
void draw_scores()
{
char left_str[10];
char right_str[10];
sprintf(left_str,"%d",LEFT_SCORE);
sprintf(right_str,"%d",RIGHT_SCORE);
//Displays the Player 1 string to the screen
glColor3f(0,1,0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(200,1400,0);
glScalef(0.6,0.6,1);
glutStrokeString(GLUT_STROKE_ROMAN, (const unsigned char *)"Player 1");
glPopMatrix();
//Displays the Player 1 score to the screen
glPushMatrix();
glTranslatef(200,1300,0);
glScalef(0.6,0.6,1);
glutStrokeString(GLUT_STROKE_ROMAN, (const unsigned char *)left_str);
glPopMatrix();
//Displays the Player 2 string to the screen
glColor3f(0,1,1);
glPushMatrix();
glTranslatef(900,1400,0);
glScalef(0.6,0.6,1);
glutStrokeString(GLUT_STROKE_ROMAN, (const unsigned char *)"Player 2");
glPopMatrix();
//Displays the Player 2 score to the screen
glPushMatrix();
glTranslatef(900,1300,0);
glScalef(0.6,0.6,1);
glutStrokeString(GLUT_STROKE_ROMAN, (const unsigned char *)right_str);
glPopMatrix();
}
static void glPrintF (int row, int col, const char *fmt, ...)
{
if (useFont == 0) return;
const float scale = 0.09f;
static char buf[128];
void *strokeFont = GLUT_STROKE_MONO_ROMAN;
void *bitmapFont = GLUT_BITMAP_9_BY_15;
static float charWidth = glutStrokeWidth(strokeFont, 35) * scale;
static float charHeight = glutStrokeHeight(strokeFont) * scale;
va_list args;
va_start(args, fmt);
vsnprintf_s(buf, 128, fmt, args);
va_end(args);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, width, 0, height, -1, 1);
glDisable(GL_LIGHTING);
glColor3f(1.0, 1.0, 0.0);
switch(useFont) {
case 1:
//StrokeString, very fast
glTranslatef(charWidth * col, height - charHeight * row, 0.0);
glScalef(scale, scale, 1);
glutStrokeString(strokeFont, (const unsigned char*)buf);
break;
case 2:
//BitmapString, high CPU load
glRasterPos2i(glutBitmapWidth(bitmapFont, ' ') * col, height - glutBitmapHeight(bitmapFont) * row);
glutBitmapString (bitmapFont, (const unsigned char*)buf);
break;
default:
//disable
break;
}
glEnable(GL_LIGHTING);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
NODE *
do_StrokeString(int nargs)
{
NODE *tmp;
void *font;
const unsigned char *string;
tmp = (NODE *) get_scalar_argument(0, FALSE);
force_string(tmp);
if ((font = str2font(tmp->stptr)) == NULL) {
// TODO
}
tmp = (NODE *) get_scalar_argument(1, FALSE);
force_string(tmp);
string = (const unsigned char *) tmp->stptr;
glutStrokeString(font, string);
return make_number((AWKNUM) 0);
}
// Draw text at the bottom of the screen.
void FullscreenUI::DrawFooterText(const std::string &text)
{
glColor4f(1, 1, 1, 1);
glPushMatrix();
glLoadIdentity();
if (m_aspectRatio > 1)
{
glScalef(1 / m_aspectRatio, 1, 1);
}
else
{
glScalef(1, m_aspectRatio, 1);
}
glScalef(0.04f, 0.04f, 1);
glTranslatef(0, -20, 0);
glTranslatef(text.length() * -0.75f, -4, 0);
glScalef(0.015f, 0.015f, 1);
glutStrokeString(GLUT_STROKE_MONO_ROMAN,
(const unsigned char *)text.c_str());
glPopMatrix();
}
void handle_draw(void) {
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(control_table[0][0],control_table[0][1],control_table[0][2],
control_table[1][0],control_table[1][1],control_table[1][2],
control_table[2][0],control_table[2][1],control_table[2][2]);
glColor3f(control_table[3][0],control_table[3][1],control_table[3][2]);
glRotatef(control_table[5][0],control_table[4][0],control_table[4][1],control_table[4][2]);
glutWireTeapot(control_table[5][1]);
// draw text
glPushMatrix();
glLoadIdentity();
glColor4f(1.0f,0.0,0.0,10.f);
glTranslatef(-7.3f,-7.2f,-18);
glScalef(0.005f,0.005f,0.005f);
glutStrokeString(GLUT_STROKE_ROMAN,(const unsigned char*)display_info.c_str());
glPopMatrix();
glutSwapBuffers();
}
void DrawStringS(int x, int y, const char* s)
{
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glTranslatef(float(x), float(y), 0.0f);
// make it match GLUT_BITMAP_8_BY_13
const float kSize = 8.0f/104.76f;
glScalef(kSize, kSize, kSize);
#if _APPLE_
while (*s)
{
glutStrokeCharacter(GLUT_STROKE_ROMAN, *s);
++s;
}
#else
glutStrokeString(GLUT_STROKE_MONO_ROMAN, (const unsigned char*)s);
#endif
glPopMatrix();
}
/*
* Writes a given string in the current( global ){font}.
* The string is drawn at the location corresponding to the modelspace
* origin, providing a somewhat unified interface for the 2 classes
* of fonts.
*/
void write_string( const char *s )
{
glDisable( GL_LIGHTING );
glColor3d( 1, 1, 1 );
if( ( GLUT_STROKE_ROMAN == font )||( GLUT_STROKE_MONO_ROMAN == font ) )
{
/*
* Stroked fonts are about 100 model units tall.
* This scales the font down to something usable in the current
* context.
*/
static GLfloat f = 1.0/64;
glScalef( f, f, f );
glutStrokeString( font, (const unsigned char*)s );
glScalef( 1/f, 1/f, 1/f );
}
else
{
glRasterPos3f( 0, 0, 0 );
glutBitmapString( font, (const unsigned char*)s );
}
glEnable( GL_LIGHTING );
}
//Displays time above the balls
void DisplayTime(mat4 modelview, mat4 projection, float time, vec3 position)
{
ostringstream convert;
int integerTime = (int)time;
convert << integerTime;
string displayNumber;
displayNumber = convert.str();
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glColor3f(0.0f, 0.0f, 0.0f);
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(value_ptr(projection));
glViewport(0, 0, window.size.x, window.size.y);
glMatrixMode(GL_MODELVIEW);
//modelview = translate(modelview, vec3(-window.ball_radius / 2.0f, 0.0f, -window.ball_radius / 2.0f));
glLoadMatrixf(value_ptr(modelview));
glTranslatef(0.0f/*-0.2f + -0.175f * (3-1)*/, window.ball_radius * 1.5f, 0.0f);
glRotatef(angleV, 0.0f, 1.0f, 0.0f);
glScaled(0.01, 0.01, 0.01);
glPushMatrix();
glutStrokeString(GLUT_STROKE_ROMAN, (const unsigned char*) displayNumber.c_str());
glPopMatrix();
}
void draw_time(int time)
{
int tempt = time;
tempt/=1000;
int tmin=tempt/60;
int tsec=tempt%60;
char str1[15],str2[15];
sprintf(str1,"%d",tmin);
sprintf(str2,"%d",tsec);
glutStrokeString(GLUT_STROKE_ROMAN,"Time ");
glutStrokeString(GLUT_STROKE_ROMAN,str1);
glutStrokeString(GLUT_STROKE_ROMAN,":");
if(tsec/10==0)
{
glutStrokeString(GLUT_STROKE_ROMAN,"0");
glutStrokeString(GLUT_STROKE_ROMAN,str2);
}
else
glutStrokeString(GLUT_STROKE_ROMAN,str2);
}
void TeleportWindow::render(int window_w, int window_h)
{
// Calculate size of 1 pixel
float ps_w = 2. / window_w; // pixelsize x-direction
float ps_h = 2. / window_h; // pixelsize y-direction
float apsr = 1.*window_w / window_h; // aspectatio
// Whole Window
glColor3f(0.0, 0.0, 0.1);
glBegin(GL_QUADS);
{
glVertex3f(-0.9, -0.9, -1.0);
glVertex3f(-0.9, 0.9, -1.0);
glVertex3f( 0.9, 0.9, -1.0);
glVertex3f( 0.9, -0.9, -1.0);
}
glEnd();
// Preview Widget
glColor3f (0.1, 0.1, 0.1);
glBegin(GL_QUADS);
{
glVertex3f(-0.45/apsr, -0.45, -1.0);
glVertex3f(-0.45/apsr, 0.45, -1.0);
glVertex3f( 0.45/apsr, 0.45, -1.0);
glVertex3f( 0.45/apsr, -0.45, -1.0);
}
glEnd();
glColor3f(1.0, 1.0, 1.0);
glRasterPos2f(-0.9 + 4 * ps_w, -0.9 + 4 * ps_h);
glutBitmapString(GLUT_BITMAP_HELVETICA_12,
(unsigned char *)"Use arrow keys up and down to select the desired action.\
Use arrow keys right and left to select your destination or type its name.");
glColor3f(1, 1, 1);
unsigned char *actionstring = (unsigned char *)
m_actions.at(m_action_selected).getDescription().c_str();
float actionstring_len = glutBitmapLength(GLUT_BITMAP_HELVETICA_18, actionstring);
glRasterPos2f(0 - actionstring_len / 2 * ps_w, 1 - 70 * ps_h);
glutBitmapString(GLUT_BITMAP_HELVETICA_18, actionstring);
float offset_l = m_destination.length() * 4.5;
glRasterPos2f(0 - offset_l * ps_w, 1 - 93 * ps_h);
glutBitmapString(GLUT_BITMAP_HELVETICA_18, (unsigned char *)m_destination.c_str());
glColor3f(1, 1, 1);
// Render preview of TeleportTarget
glPushAttrib(GL_ENABLE_BIT);
{
glEnable (GL_DEPTH);
glEnable (GL_DEPTH_TEST);
glEnable (GL_BLEND);
glScalef(1.0f / apsr, 1.0f, 1.0f);
glTranslatef(0.0f, 0.0f, -1.0f);
if (m_target)
m_target->renderPreview(m_preview_time, 0.4f);
else
{
// Draw Wire Sphere
glLineWidth(2.0);
glPushMatrix();
{
glRotatef(m_preview_time * TELEPORT_PREVIEW_ROTSPEED, 0, 1, 0);
glRotatef(90, 1, 0, 0);
glutWireSphere(0.4, 20, 20);
}
glPopMatrix();
// Draw red question mark
glPushMatrix();
{
glColor3f(1.0f, 0.0f, 0.0f);
glLineWidth(5.0);
float textsize = 0.5;
float font_height = textsize / glutStrokeHeight(GLUT_STROKE_MONO_ROMAN);
float font_width = textsize / glutStrokeLength(GLUT_STROKE_MONO_ROMAN,
(unsigned char *)"?");
glTranslatef(0.0f, 0.0f, 1.0f);
glRotatef(m_preview_time * TELEPORT_PREVIEW_ROTSPEED, 0, 1, 0);
glTranslatef(-textsize / 2, -textsize / 4, 0.4f);
glScalef(font_width, font_height, font_width);
glutStrokeString(GLUT_STROKE_MONO_ROMAN, (unsigned char *)"?");
}
}
}
glPopAttrib();
}
void DrawObject(float x,float y,float z,float rotation,float width,float height,unsigned int decal_type,char * text)
{
glPushMatrix();
//glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
if (frame.try_for_best_render_quality)
{
glEnable(GL_NORMALIZE);
glEnable(GL_LINE_SMOOTH);
}
glTranslated(x,y,z);
if ( rotation!=0 ) { glRotated(rotation,0.0,0.0,1.0); }
if ( decal_type != 0 )
{ //Decal type zero may only have text :P
glEnable ( GL_TEXTURE_2D );
/* DRAW FRAME >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/
glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE);
if ( decal_type == 1 ) glBindTexture(GL_TEXTURE_2D, heart->gpu.gl_rgb_texture ); else
if ( decal_type == 2 ) glBindTexture(GL_TEXTURE_2D, star->gpu.gl_rgb_texture ); else
if ( decal_type == 3 ) glBindTexture(GL_TEXTURE_2D, play_img->gpu.gl_rgb_texture ); else
if ( decal_type == 4 ) glBindTexture(GL_TEXTURE_2D, pause_img->gpu.gl_rgb_texture ); else
if ( decal_type == 5 ) glBindTexture(GL_TEXTURE_2D, label->gpu.gl_rgb_texture ); else
glBindTexture(GL_TEXTURE_2D, heart->gpu.gl_rgb_texture ); /* DEFAULT */
glBegin(GL_QUADS);
glColor3f(1.0,1.0,1.0);
float size_x=width,size_y=height;
float xmin=(-1)*size_x/2,xmax=size_x/2,ymin=(-1)*size_y/2,ymax=size_y/2;
glTexCoord2f(1.0f, 0.0f); glVertex3f(0+xmin,0+ymin,0/*-4.1*/); // Bottom Left Of The Texture and Quad
glTexCoord2f(0.0f, 0.0f); glVertex3f(0+xmax,0+ymin,0/*-4.1*/); // Bottom Right Of The Texture and Quad
glTexCoord2f(0.0f, 1.0f); glVertex3f(0+xmax,0+ymax,0/*-4.1*/); // Top Right Of The Texture and Quad
glTexCoord2f(1.0f, 1.0f); glVertex3f(0+xmin,0+ymax,0/*-4.1*/);
glEnd();
glDisable ( GL_TEXTURE_2D );
glDisable(GL_BLEND);
}
if (text!=0)
{
if (frame.lighting_enabled) { glDisable( GL_LIGHTING ); }
glColor3f(1.0,1.0,1.0);
glRasterPos3f(width/2,0,0.1);
//glutBitmapString(GLUT_BITMAP_TIMES_ROMAN_24,(const unsigned char*)text);
glPushMatrix();
glRotated(180,0.0,0.0,1.0);
glTranslated(-10,0,0);
glLineWidth(3.0);
static GLfloat f = 1.0/110;
glScalef( f, f, f );
glutStrokeString(GLUT_STROKE_ROMAN,(const unsigned char*)text); //GLUT_STROKE_ROMAN GLUT_STROKE_MONO_ROMAN
glScalef( 1/f, 1/f, 1/f );
glLineWidth(1.0);
glTranslated(0,0,0);
glRotated(-180,0.0,0.0,1.0);
glPopMatrix();
if (frame.lighting_enabled) { glEnable( GL_LIGHTING ); }
}
if ( rotation!=0 ) { glRotated(-rotation,0.0,0.0,1.0); }
glTranslated(-x,-y,-z);
if (frame.try_for_best_render_quality)
{
glDisable(GL_LINE_SMOOTH);
glDisable(GL_NORMALIZE);
}
glPopMatrix();
}
/******************************************************************************
* Function: showStartScreen()
* Authors: Ian Carlson, Christopher Smith
* Description: Displays the start screen for controls of game
* ****************************************************************************/
void showStartScreen()
{
//Displays player 1 Controls
glColor3f(1,1,1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef( 100, 1150, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"PLAYER 1 CONTROLS:" );
glPopMatrix();
glPushMatrix();
glTranslatef( 150, 950, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"W,w: Move Up" );
glPopMatrix();
glPushMatrix();
glTranslatef( 150, 800, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"D,d: Move Down" );
glPopMatrix();
glPushMatrix();
glTranslatef( 150, 650, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"A,a: Move Left" );
glPopMatrix();
glPushMatrix();
glTranslatef( 150, 500, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"D,d: Move Right" );
glPopMatrix();
glPushMatrix();
glTranslatef( 150, 350, 0 );
//Displays the universal controls for speeds and pause
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"Q, q & E, e: Rotate Left/Right" );
glPopMatrix();
glPushMatrix();
glTranslatef( 500, 250, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"Spacebar, p, P: Pause Start Game" );
glPopMatrix();
glPushMatrix();
glTranslatef( 500, 150, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"+, -: Speed Up/Slow Ball" );
glPopMatrix();
glPushMatrix();
glTranslatef( 500, 50, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"*, /: Speed Up/Slow Paddles" );
glPopMatrix();
//Displays the Controls for Player 2
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef( 900, 1150, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"PLAYER 2 CONTROLS:" );
glPopMatrix();
glPushMatrix();
glTranslatef( 940, 950, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"Up Arrow, 8: Move Up" );
glPopMatrix();
glPushMatrix();
glTranslatef( 940, 800, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"Down Arrow, 5, 2: Move Down" );
glPopMatrix();
glPushMatrix();
glTranslatef( 940, 650, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"Left Arrow, 4: Move Left" );
glPopMatrix();
glPushMatrix();
glTranslatef( 940, 500, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"Right Arrow, 6: Move Right" );
glPopMatrix();
glPushMatrix();
glTranslatef( 940, 350, 0 );
// while ( *string ) glutStrokeCharacter( GLUT_STROKE_ROMAN, *string++ );
glScalef(0.3,0.3,1);
glutStrokeString( GLUT_STROKE_ROMAN, (const unsigned char *)"7, Home & 9, PgUp: Rotate Left/Right" );
glPopMatrix();
glPushMatrix();
}
