Incorrect random coloured rectangle - c++

I want to display random colors in the GL_POLYGON.
But the colors changes only on minimize and maximize.It picks a different color on maximization and a different color on minimization.But it randomizes the colors as long as i continue minimizing and maximizing
#include <GL/gl.h>
#include <GL/glut.h>
#include <cstdlib>
void display( void )
{
glClear( GL_COLOR_BUFFER_BIT );
glBegin( GL_POLYGON );
for( int i = 0; i < 255; i++ )
{
glColor3ub( rand(), rand(), rand() );
}
glVertex3f( 0.25, 0.25, 0.0 );
glVertex3f( 0.75, 0.25, 0.0 );
glVertex3f( 0.75, 0.75, 0.0 );
glVertex3f( 0.25, 0.75, 0.0 );
glEnd();
glColor3f( 0.0, 0.0, 0.0 );
glRectf( 0.45, 0.25, 0.55, 0.05 );
glRectf( 0.35, 0.08, 0.65, 0.02 );
glFlush();
}
void init( void )
{
glClearColor( 1.0, 1.0, 1.0, 1.0 );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho( 0.0, 1.0, 0.0, 1.0, -1.0, 1.0 );
}
int main( int argc, char** argv )
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_SINGLE | GLUT_RGB );
glutInitWindowSize( 250, 250 );
glutInitWindowPosition( 100, 100 );
glutCreateWindow( "Assignment" );
init();
glutDisplayFunc( display );
glutMainLoop();
return 0;
}

glutDisplayFunc() only calls your callback when the OS needs your window re-drawn. If you want more regular calls you need to trigger them yourself via glutPostRedisplay():
... When GLUT determines that the normal plane for the window needs to be redisplayed, the display callback for the window is called. ...
...
GLUT determines when the display callback should be triggered based on the window's redisplay state. The redisplay state for a window can be either set explicitly by calling glutPostRedisplay or implicitly as the result of window damage reported by the window system. Multiple posted redisplays for a window are coalesced by GLUT to minimize the number of display callbacks called.
I like to use glutTimerFunc() to call glutPostRedisplay() periodically:
#include <GL/glut.h>
#include <cstdlib>
void timer( int value )
{
glutPostRedisplay();
glutTimerFunc( 16, timer, 0 );
}
void display()
{
glClearColor( 0.2, 0.2, 0.2, 1 );
glClear( GL_COLOR_BUFFER_BIT );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glBegin( GL_POLYGON );
glColor3ub( rand(), rand(), rand() );
glVertex3f( 0.25, 0.25, 0.0 );
glVertex3f( 0.75, 0.25, 0.0 );
glVertex3f( 0.75, 0.75, 0.0 );
glVertex3f( 0.25, 0.75, 0.0 );
glEnd();
glColor3f( 0.0, 0.0, 0.0 );
glRectf( 0.45, 0.25, 0.55, 0.05 );
glRectf( 0.35, 0.08, 0.65, 0.02 );
glutSwapBuffers();
}
int main( int argc, char** argv )
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE );
glutInitWindowSize( 250, 250 );
glutCreateWindow( "GLUT" );
glutDisplayFunc( display );
glutTimerFunc( 0, timer, 0 );
glutMainLoop();
return 0;
}

Related

Drawing random points/stars using OpenGL?

I am trying to draw some random points as the star in the window,
but points are not showing. But others objects are showing correctly.
My source code:
#include<windows.h>
#include <GL\glut.h>
#include <math.h> // For math routines (such as sqrt & trig).
GLfloat xRotated, yRotated, zRotated;
GLdouble radius=3;
GLfloat qaBlack[] = {0.0, 0.0, 0.0, 1.0}; //Black Color
GLfloat qaGreen[] = {0.0, 1.0, 0.0, 1.0}; //Green Color
GLfloat qaWhite[] = {1.0, 1.0, 1.0, 1.0}; //White Color
GLfloat qaRed[] = {1.0, 0.0, 0.0, 1.0}; //Red Color
// Set lighting intensity and color
GLfloat qaSpecularLight[] = {1.0, 1.0, 1.0, 1.0};
GLfloat emitLight[] = {0.9, 0.9, 0.9, 0.9};
GLfloat Noemit[] = {0.0, 0.0, 0.0, 1.0};
// Light source position
GLfloat qaLightPosition[] = {1, 1, 1, 1};
void display(void);
void reshape(int x, int y);
void idleFunc(void)
{
if ( zRotated > 360.0 ) {
zRotated -= 360.0*floor(zRotated/360.0); // Don't allow overflow
}
if ( yRotated > 360.0 ) {
yRotated -= 360.0*floor(yRotated/360.0); // Don't allow overflow
}
zRotated += 0.05;
yRotated +=0.01;
display();
}
void initLighting()
{
// Enable lighting
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_SPECULAR, qaSpecularLight);
}
void display(void){
glMatrixMode(GL_MODELVIEW);
// clear the drawing buffer.
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
// clear the identity matrix.
glLoadIdentity();
glTranslatef(0.0,0.0,-40.0);
glPushMatrix();
glutSolidSphere(radius,25,25);
glPopMatrix();
glPopMatrix();
glPushMatrix();
glRotatef(yRotated,0.0,2.0,0.0);
glTranslatef(5.0,0.0,0.0);
// Set the light position
glLightfv(GL_LIGHT0, GL_POSITION, qaLightPosition);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emitLight); // Make sphere glow (emissive)
glutSolidSphere(radius/6,25,25);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Noemit);
glPopMatrix();
glTranslatef(0.0,0.0,0.0);
glPushMatrix();
glColor3f(1.0, 1.0, 1.0);
glPointSize(3);
for(int i=1;i<100;i++){
int x = rand()%640 ;
int y = rand()%480;
glBegin(GL_POINTS);
glVertex2i (x,y);
glEnd();
}
glPopMatrix();
glLoadIdentity();
glColor3f(1.0, 1.0, 1.0);
glPointSize(3);
for(int i=1;i<100;i++){
int x = rand()%640 ;
int y = rand()%480;
glBegin(GL_POINTS);
glVertex2i (x,y);
glEnd();
}
glFlush(); //FOR RENDERING
glutSwapBuffers();
}
void reshape(int x, int y){
if(y == 0 || x == 0) return;
glMatrixMode(GL_PROJECTION);
gluPerspective(20.0,(GLdouble)x/(GLdouble)y,0.6,40.0);
glMatrixMode(GL_MODELVIEW);
glViewport(0,0,x,y); //Use the whole window for rendering
}
int main (int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutInitWindowSize(1000,600);
glutCreateWindow("Project_KD");
initLighting();
xRotated = yRotated = zRotated = 0.0;
glutIdleFunc(idleFunc);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}
Lots of wonkiness:
Couple instances of unmatched glPushMatrix()/glPopMatrix() calls; avoid over-/under-flowing the matrix stack; I like to use extra scopes to visually indicate matrix stack nesting.
Your point drawing was assuming an ortho projection while you only set a perspective one.
You left lighting enabled while trying to draw your points, resulting in very dark points everywhere except the bottom-left.
Your point drawing loop was duplicated for some reason; if you want double the stars adjust the for-loop end value instead of copy-pasting the loop.
You should use glutPostRedisplay() in your idle callback instead of calling display() directly.
Set your projection/modelview matrices each time through display() instead of setting them in a resize callback; helps reduce a source of mysterious matrix errors. The default resize callback calls glViewport() for you so you don't have to worry about doing that.
You're drawing the points ("stars"?) after the 3D spheres; I think the intent was to draw them before so they're "underneath".
Unholy mishmash of code formatting; recommend something like clang-format to keep that in check.
If you're using FreeGLUT on Windows (which you ought to be; it's really the only maintained GLUT implementation left) you don't need the #include <Windows.h>.
Recommend using a timer callback instead of an idle callback to update your simulation/animation. Without vsync that idle callback will be called incredibly often. With a timer callback you can simulate the even ~16 millisecond frames a vsync'd system will give you.
All together:
#include <GL/glut.h>
#include <cmath>
GLfloat xRotated, yRotated, zRotated;
GLdouble radius = 3;
void timer( int value )
{
if( zRotated > 360.0 )
{
zRotated -= 360.0 * floor( zRotated / 360.0 ); // Don't allow overflow
}
if( yRotated > 360.0 )
{
yRotated -= 360.0 * floor( yRotated / 360.0 ); // Don't allow overflow
}
zRotated += 5.0;
yRotated += 1.0;
glutTimerFunc( 16, timer, 0 );
glutPostRedisplay();
}
void display()
{
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glDepthMask( GL_FALSE );
glDisable( GL_DEPTH_TEST );
glDisable( GL_LIGHTING );
// 2D rendering
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho( 0, 640, 0, 480, -1, 1 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glPushMatrix();
{
glColor3f( 1.0, 1.0, 1.0 );
glPointSize( 3 );
glBegin( GL_POINTS );
for( int i = 1; i < 100; i++ )
{
int x = rand() % 640;
int y = rand() % 480;
glVertex2i( x, y );
}
glEnd();
}
glPopMatrix();
glDepthMask( GL_TRUE );
glEnable( GL_DEPTH_TEST );
// Enable lighting
glEnable( GL_LIGHTING );
glEnable( GL_LIGHT0 );
GLfloat qaSpecularLight[] = {1.0, 1.0, 1.0, 1.0};
glLightfv( GL_LIGHT0, GL_SPECULAR, qaSpecularLight );
// 3D rendering
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
double w = glutGet( GLUT_WINDOW_WIDTH );
double h = glutGet( GLUT_WINDOW_HEIGHT );
gluPerspective( 20.0, w / h, 0.1, 80.0 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glTranslatef( 0.0, 0.0, -40.0 );
glPushMatrix();
{
glutSolidSphere( radius, 25, 25 );
}
glPopMatrix();
glPushMatrix();
{
glRotatef( yRotated, 0.0, 2.0, 0.0 );
glTranslatef( 5.0, 0.0, 0.0 );
GLfloat qaLightPosition[] = {1, 1, 1, 1};
glLightfv( GL_LIGHT0, GL_POSITION, qaLightPosition );
GLfloat emitLight[] = {0.9, 0.9, 0.9, 0.9};
glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, emitLight ); // Make sphere glow (emissive)
glutSolidSphere( radius / 6, 25, 25 );
GLfloat Noemit[] = {0.0, 0.0, 0.0, 1.0};
glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, Noemit );
}
glPopMatrix();
glutSwapBuffers();
}
int main( int argc, char** argv )
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutInitWindowSize( 1000, 600 );
glutCreateWindow( "Project_KD" );
xRotated = yRotated = zRotated = 0.0;
glutDisplayFunc( display );
glutTimerFunc( 0, timer, 0 );
glutMainLoop();
return 0;
}

Display window and line segment in OpenGL

The line isn't showing up. What is wrong with the code?
#include<windows.h>
//#ifdef __APPLE__
//#include <GLUT/glut.h>
//#else
#include <GL/glut.h>
//#endif
//#include <stdlib.h>
void init(void){
glClearColor(1.0, 1.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0.0, 200.0, 0.0,150.0);
}
void lineSegment(void){
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0f, 0.0f, 0.0f); // Red
//glColor3f(0.2, 0.4, 0.2);
glBegin(GL_LINE);
glVertex2i(180,15);
glVertex2i(10,145);
glEnd();
glFlush();
}
int main(int argc, char* argv[]){
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE); // Enable double buffered mode
//glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowPosition(50,100);
glutInitWindowSize(400,300);
glutCreateWindow("An example OpenGL Program");
init();
glutDisplayFunc(lineSegment);
glutMainLoop();
return 0;
}
You're requesting a GLUT_DOUBLE-buffered window but are failing to call glutSwapBuffers() at the end of your glutDisplayFunc() callback. glFlush() is not sufficient.
GL_LINE is not a valid argument for glBegin(). You're thinking of GL_LINES.
All together:
#include <GL/glut.h>
void init()
{
glClearColor( 1.0, 1.0, 1.0, 0.0 );
glMatrixMode( GL_PROJECTION );
gluOrtho2D( 0.0, 200.0, 0.0, 150.0 );
}
void lineSegment()
{
glClear( GL_COLOR_BUFFER_BIT );
glColor3f( 1.0f, 0.0f, 0.0f ); // Red
glBegin( GL_LINES );
glVertex2i( 180, 15 );
glVertex2i( 10, 145 );
glEnd();
glutSwapBuffers();
}
int main( int argc, char* argv[] )
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DOUBLE ); // Enable double buffered mode
glutInitWindowSize( 400, 300 );
glutCreateWindow( "An example OpenGL Program" );
init();
glutDisplayFunc( lineSegment );
glutMainLoop();
return 0;
}

Set pixel color to a sphere in OpenGL

I have used QUAD_STRIP to display squares with different colours and a mouse function to capture the color. The captured color should be set to a spehre. I can read color values but I'm unable to set the read color values to the sphere. Sphere is not displayed when given within mouse function. But shows up when given in display() function.
#include <stdlib.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include<windows.h>
float height=480,width=500;
GLUquadricObj *sphere = NULL;
GLubyte *img;
static void Init() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glShadeModel(GL_FLAT);
sphere = gluNewQuadric();
gluQuadricDrawStyle(sphere, GLU_FILL);
gluQuadricTexture(sphere, GL_TRUE);
gluQuadricNormals(sphere, GLU_SMOOTH);
glClearColor(1,1,1,0);
}
static void display() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//glColor3f(0.0f, 0.0f, 0.0f); // sets color to black.
glBegin(GL_QUAD_STRIP);
//1 q
glColor3f(.5,0.5,1);
glVertex2f(-1, 0.5 );
glVertex2f(-1, 0.75 );
glVertex2f(-0.75, 0.5 );
glVertex2f(-0.75, 0.75 );
// 2q
glColor3f(.25,.5,0);
glVertex2f(-0.5, 0.5 );
glVertex2f(-0.5, 0.75 );
//3q
glColor3f(0.8,0.8,0.4);
glVertex2f(-0.25, 0.5 );
glVertex2f(-0.25, 0.75 );
// 4th QUAD
glColor3f(0.7,0.3,0.6);
glVertex2f(0, 0.5);
glVertex2f(0, 0.75 );
// 5th QUAD
glColor3f(0, 0.7,0.3);
glVertex2f( 0.25, 0.5);
glVertex2f(0.25, 0.75 );
glEnd();
glBegin(GL_QUAD_STRIP);
//1 q
glColor3f(.5,0.5,.5);
glVertex2f(-1, 0.25 );
glVertex2f(-1, 0.5 );
glVertex2f(-0.75, 0.25 );
glVertex2f(-0.75, 0.5 );
// 2q
glColor3f(.5,0.1,0.1);
glVertex2f(-0.5, 0.25 );
glVertex2f(-0.5, 0.5 );
//3q
glColor3f(0.1,0.1,0.4);
glVertex2f(-0.25, 0.25 );
glVertex2f(-0.25, 0.5 );
// 4th QUAD
glColor3f(1,1,0.5);
glVertex2f(0, 0.25);
glVertex2f(0, 0.5 );
// 5th QUAD
glColor3f(0.76, 0.3,0);
glVertex2f( 0.25, 0.25);
glVertex2f(0.25, 0.5 );
glEnd();
glBegin(GL_QUAD_STRIP);
//1 q
glColor3f(.5,0,.5);
glVertex2f(-1, 0 );
glVertex2f(-1, 0.25 );
glVertex2f(-0.75, 0 );
glVertex2f(-0.75, 0.25 );
// 2q
glColor3f(.5,.3,0.3);
glVertex2f(-0.5, 0 );
glVertex2f(-0.5, 0.25 );
//3q
glColor3f(0.2,0.3,0);
glVertex2f(-0.25, 0 );
glVertex2f(-0.25, 0.25 );
// 4th QUAD
glColor3f(0,0,0);
glVertex2f(0, 0);
glVertex2f(0, 0.25 );
// 5th QUAD
glColor3f(1.0, 0,.5);
glVertex2f( 0.25, 0);
glVertex2f(0.25, 0.25 );
glEnd();
glBegin(GL_QUAD_STRIP);
glColor3f(1,0.5,0);
glVertex2f(-1, -0.25 );
glVertex2f(-1, 0.0 );
glVertex2f(-0.75, -0.25 );
glVertex2f(-0.75, 0.0 );
glColor3f(1.0,1.0,0.0);
glVertex2f(-0.5, -0.25 );
glVertex2f(-0.5, 0.0 );
glColor3f(0.0,0.0,1.0);
glVertex2f(-0.25, -0.25 );
glVertex2f(-0.25, 0.0 );
// 2nd QUAD
glColor3f(1.0, 0.0, 0.0);
glVertex2f(-0.25, -0.25 );
glVertex2f(-0.25, 0.0 );
glVertex2f( 0, -0.25 );
glVertex2f(0, 0.0 );
// 3rd QUAD
glColor3f(0.0, 1.0, 0.0);
glVertex2f( 0.25, -0.25 );
glVertex2f(0.25, 0.0 );
glEnd();
glutSwapBuffers();
}
void moveBall(int key, int x, int y) {
}
void mouseMove(int x,int y) {
y = glutGet( GLUT_WINDOW_HEIGHT ) - y;
GLubyte pixel[3];
float r,g,b;
glReadPixels(x, y, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, pixel);
r = pixel[0]/255.0;
g = pixel[1]/255.0;
b = pixel[2]/255.0;
printf("red %f",r);
printf("green %f",g);
printf("blue %f",b);
glColor3f(r,g,b);
glTranslatef(0.75,0.25,0);
gluSphere(sphere,0.1,20,20);
}
int main(int argc, char** argv) {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutInitWindowPosition( 10, 10);
glutInitWindowSize(height,width);
glutCreateWindow( "ColorBlocks");
Init();
glutDisplayFunc(display);
glutSpecialFunc(moveBall);
glutMotionFunc(mouseMove);
glutMainLoop();
}
What you should do is put the drawing of the sphere in the display and position it using the variables you get in mouseMove and have set to a global:
float sphereR,sphereG,sphereB;
void display(){
//everything before the glutSwapBuffers(); call...
glPushMatrix()
glColor3f(r,g,b);
glTranslatef(0.75,0.25,0);
gluSphere(sphere,0.1,20,20);
glPopMatrix()
glutSwapBuffers();
}
void mouseMove(int x,int y) {
y = glutGet( GLUT_WINDOW_HEIGHT ) - y;
GLubyte pixel[3];
glReadPixels(x, y, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, pixel);
sphereR = pixel[0]/255.0;
sphereG = pixel[1]/255.0;
sphereB = pixel[2]/255.0;
printf("red %f",r);
printf("green %f",g);
printf("blue %f",b);
}

How to draw connected strip lines in OpenGL like this

I want to draw a series of connected lines (GL_LINE_STRIP) in following way.
I had tried to code by my own, but not get desired result, so i come here, help me to find out where i was wrong. here i am giving only my draw() function.
glBegin(GL_LINE_STRIP);
glVertex2f(-4.00, 0.00);
glVertex2f(-3.00, 2.00);
glVertex2f(-2.00, 0.00);
glVertex2f(-1.00, 2.00);
glVertex2f(0.0, 0.00);
glVertex2f(1.00, 2.00);
glVertex2f(2.00, 0.00);
glVertex2f(3.00, 2.00);
glVertex2f(4.00, 0.00);
glEnd();
Workin' perfectly here:
#include <GL/glut.h>
void display()
{
glClear( GL_COLOR_BUFFER_BIT );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho( -6, 6, -6, 6, -1, 1);
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glColor3ub( 255, 255, 255 );
glBegin(GL_LINE_STRIP);
glVertex2f(-4.00, 0.00);
glVertex2f(-3.00, 2.00);
glVertex2f(-2.00, 0.00);
glVertex2f(-1.00, 2.00);
glVertex2f(0.0, 0.00);
glVertex2f(1.00, 2.00);
glVertex2f(2.00, 0.00);
glVertex2f(3.00, 2.00);
glVertex2f(4.00, 0.00);
glEnd();
glutSwapBuffers();
}
int main( int argc, char **argv )
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_RGBA | GLUT_DOUBLE );
glutInitWindowSize( 600, 600 );
glutCreateWindow( "GLUT" );
glutDisplayFunc( display );
glutMainLoop();
return 0;
}

push and pop matrix in stack (openGL)

I have knew that there is some problem in this code as if I run it nothing is drawn .
portion of program where wrong is located in this code
void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity ();
glPushMatrix();
glRotated((GLdouble) Vangle,1.0,0.0,0.0);
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glPopMatrix();
glutWireCube (1.0);
glFlush ();
}
can you tell what is wrong ?
I think in matrix stack methods (push and pop) , I do not know how do I use it
Note : value of Vangle is zero .
As pst pointed out: Move the glutWireCube() call inside the glPush/PopMatrix() pair.
Give this a shot:
#include <GL/glut.h>
void display()
{
glEnable( GL_DEPTH_TEST );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
// projection
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
double w = glutGet( GLUT_WINDOW_WIDTH );
double h = glutGet( GLUT_WINDOW_HEIGHT );
double ar = w / h;
gluPerspective( 60, ar, 0.1, 100 );
// "camera" transform
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
// draw cube
glPushMatrix();
float Vangle = 0.0f;
glRotated((GLdouble) Vangle,1.0,0.0,0.0);
glutWireCube (1.0);
glPopMatrix();
glutSwapBuffers();
}
int main( int argc, char **argv )
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE );
glutInitWindowSize( 640, 480 );
glutCreateWindow( "GLUT" );
glutDisplayFunc( display );
glutMainLoop();
return 0;
}