lunes, 29 de octubre de 2012

Tecnicas de sombrado clásicas y avanzadas.


Ejemplo de sombreado en opengl:
glBegin(GL_TRIANGLES);
glColor3f(1.0f, 0.0f, 0.0f);
glVertex3f(0.0f,0.0f, 0.0f);
glVertex3f(2.0f,0.0f, 0.0f);
glVertex3f(1.0f,1.0f, 0.0f);

glColor3f(0.0f,1.0f, 0.0f);
glVertex3f(-1.0f,0.0f, 0.0f);
glVertex3f(-3.0f,2.0f, 0.0f);
glVertex3f(-2.0f,0.0f, 0.0f);
glEnd();
**************************************************************

Iluminación local:

Se denomina como luces que no son extensas, como las reales, sino inextensas, puntuales y son relacionadas con los objetos como mónedas aisladas, sin tener en cuenta la interacción entre ellos.

Las insuficiencias de los métodos de iluminación local se han superado en parte por medio de sistemas de iluminación global que permiten tomar en cuenta la interacción entre objetos. Las dos técnicas principales son el trazado de rayos y la radiosidad.

Posterior relleno de triángulos
Rellenado de los triángulos (rastering). Para ello se realizan varias fases de procesamiento por Pixel. Comprobar si cada nuevo pixel es visible o no (comprobación de profundidad).
Interpolación lineal del color para el nuevo pixel (método de Gouraud).

Si existe una textura definida o transparencia, efectuar la modificación de color correspondiente.

Se trata de la última fase, en ocasiones la más costosa, del proceso, por lo que es la primera que se suele integrar en el hardware gráfico. En esta etapa se trata de asignar colores a los pixels correspondientes al interior de cada triángulo proyectado que cae dentro del área de visualización. Los colores asignados deben calcularse por el método de Gouraud, interpolando linealmente entre los colores de los tres vértices

Cálculos de iluminación por vértices
Para poder aplicar iluminación necesitamos asociar a cada vértice de nuestro objeto un vector normal asociado. Cuando tenemos la normal calculada tenemos que normalizarla, o sea, dividir ese vector por su propio modulo para que sea unitario, pero también podemos hacer que se encargue la OpengGl activando la normalización,


Renderizado en tiempo real:

La idea fundamental del procesado en tiempo real es que todos los objetos deben ser descompuestos en polígonos. Estos polígonos serán descompuestos a su vez en triángulos. Cada triángulo será proyectado sobre la ventana bidimensional y rellenado con los colores adecuados para reflejar los efectos de la iluminación, texturas, etc. Una vez se han generado los triángulos, en la pipeline existen dos partes claramente diferenciadas: una primera etapa operaciones realizadas sobre cada uno de los vértices, y después de que éstos se proyecten sobre la ventana, entonces comienza una segunda fase de cálculos realizados para cada pixel cubierto por los triángulos.

Iluminación global.

Son sencillos y rápidos pero proporcionan imágenes muy simples, que no representan adecuadamente el modo en que la luz ilumina los objetos y los espacios. Esto no quiere decir que no sean útiles para un gran número de casos, y es muy importante calibrar adecuadamente que es lo que se necesita, pues puede muy bien ocurrir que un cálculo local proporcione imágenes relativamente esquemáticas pero más adecuadas para la representación de un proyecto.
Los métodos principales que existen en la actualidad pueden considerarse como desarrollos, con diferentes variantes, de los dos métodos principales que surgieron en la década de los 1980, ray tracing (introducido por T.Whitted en 1980) y radiosity (hacia 1984 por varios autores). Una base téorica más firme para los algoritmos y métodos de GI (Global Illumination), vino con la publicación, por Kajiya, en 1986 de la rendering equation, que puede encontrarse en un manual especializado.

Interpolación de Intensidades (Gouraud).
Se basa en la interpolación de intensidad o color
Considera que facetas planas vecinas proceden deaproximar una superficie curva (salvo que se declare una arista real entre ambas)
*Elimina en gran medida las discontinuidades de iluminación
*Es sencilla, pero produce peores resultados en objetos con brillos especulares que el método de Phong
*Implementado en OpenGL
· Calcula normales al polígono
La iluminación cte. no produce buenos resultados en superficies curvas (aprox. por
facetas planas).

Evaluar la ecuación de iluminación en cada punto de una superficie genérica es muy costoso. Posible solución: aproximar mediante facetas planas e interpolar dentro de cada polígono. Hay que evitar producir una apariencia “faceteada” (bandas de Mach; respuesta del ojo humano).

Interpolacion de normales de Pong
• Se basa en la interpolación de la dirección de la normal, calculada de la misma forma que antes.
• Igual que en Gouraud, se interpola a lo largo de cada línea de barrido, entre los puntos inicial y final, interpolados a su vez de los valores de los vértices de la arista.
• Captura mejor los brillos especulares en el medio de facetas planas (Gouraud los puede omitir).
Produce mejores resultados, a un coste computacional mayor (hay que incrementar la dirección de la normal en tres direcciones, normalizarla y calcular la ecuación de sombreado encada punto)
• Si el coeficiente de reflexión especular es pequeño, los resultados no difieren tanto (se pueden combinar objetos sombreados por ambos métodos en una escena).
·Ray Tracing
En muchas formas, ray tracing es una extensión al enfoque de rendering con un modelo de iluminación local. Está basado en la observación previa que, de los rayos de luz saliendo de una fuente, los únicos que contribuyen a la imagen son aquellos que entran el lente de la cámara sintética y pasan por el centro de proyección.

·Buffer de Profundidad.
El Z-Buffer se basa en que al generar la posición de un punto en la pantalla la computadora reserve una zona de memoria especial, llamada Z-Buffer, información relacionada con la profundidad del punto que ocupa en la escena representada. Cuando el ordenador representa un nuevo punto consulta el Z-Buffer del píxel que corresponde en pantalla. Si el valor que ya existe en el píxel es mayor que el que posee el nuevo punto, el sistema asume que este último es el visible y lo sustituye en la memoria del Z- Buffer.

·Buffer Stencil.
Stencill Buffer es una memoria intermedia que analiza y actualiza píxeles (con sus operaciones) junto con “depth buffer” o buffer de profundidad. Añade planos de bits adicionales para cada píxel además de los bits de color y profundidad.
Stencil buffer es similar al buffer de profundidad en que los dos son colección de planos de bit que no se pueden mostrar. Del mismo modo que el buffer de profundidad asocia a cada píxel de la ventana un valor de profundidad, el stencil buffer asocia su propio valor a cada píxel mostrado. Cuando el buffer de profundidad esta activado los valores de profundidad son usados para aceptar o rechazar fragmentos, del mismo modo los valores de Stencil buffer son usados para aceptar o rechazar fragmentos.

· Fuentes de Color
No solamente las fuentes de luz emiten diferentes cantidades de luz en diferentes frecuencias, pero también sus propiedades direccionales varían con la frecuencia. Por lo tanto, un modelos físicamente correcto puede ser muy complejo. Para la mayoría de las aplicaciones, se puede modelar fuentes de luz en base a tres componentes primarios, RGB, y puede usar cada uno de los tres colores fuentes para obtener el componente de color correspondiente que un observador humano vería.

Luz Ambiente
La luz ambiente ilumina por igual todas las zonas en sombra para simular el efecto de interacción entre objetos que hace que las partes en sombra de los objetos queden parcialmente iluminadas.

En algunos cuartos, las luces se diseñan y ubican para proveer iluminación uniforme en el cuarto. Tal iluminación se logra mediante fuentes grandes con difusores cuyo propósito es esparcir la luz en todas las direcciones. Se puede crear una simulación precisa de tal iluminación, modelando todas las fuentes distribuidas, y luego integrando la iluminación de estas fuentes en cada punto de una superficie reflectora. Hacer tal modelo y generar la escena sería un tarea formidable para un sistema gráfico, especialmente si se desea ejecución en tiempo real. De manera alternativa, se puede ver el efecto deseado de las fuentes: lograr un nivel de luz uniforme en el cuarto. Esta iluminación uniforme se llama luz ambiente. Si se sigue este segundo enfoque, se puede postular una intensidad ambiente en cada punto del ambiente. Por lo tanto, iluminación ambiente se caracteriza por una intensidad Ia, que es idéntica en cada punto de la escena.

· Spotlights (direccionales)
Los spotlights se caracterizan por un rango delgado de ángulos por los cuales se emite luz. Se puede construir un spotlight sencillo de una fuente de punto limitando los ángulos de donde la luz de la fuente se puede ver. Se puede usar un cono cuyo ápice está en ps, apuntando en la dirección ls, y cuyo ancho está determinado por el ángulo
θ.

Fuentes de Luz Distantes
La mayor
ía de los cálculos de sombreado requieren la dirección de un punto sobre la superficie a la fuente de luz. Según se mueve a lo largo de la superficie, se debe recomputar este vector para calcular la intensidad en cada punto, una computación que es una parte significativa del cálculo del sombreado. Sin embargo, si la fuente de luz está lejos de la superficie, el vector no cambiará mucho según se mueve de un punto a otro, al igual que la luz del sol da en todos los objetos cercanos entre si con el mismo ángulo

martes, 23 de octubre de 2012

Piramide girando en eje y

 
codigo
#include <GL/glut.h>

GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;

GLint ancho=500;
GLint alto=500;
 

void reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
   
   
 glOrtho(-4,4, -4, 4, 1, 10);
    glMatrixMode(GL_MODELVIEW);

    ancho = width;
    alto = height;
}

void drawCube(void)
{
 
  glClear(GL_COLOR_BUFFER_BIT);
//CARA atras

 glShadeModel(GL_SMOOTH);
   glBegin(GL_TRIANGLES);
  glColor3f(1.0,0.0,0.0);
  glVertex3d(1.5,0,1.5);
 glColor3f(0.0,1.0,0.0);
glVertex3d(0,3,0);
 glColor3f(0.0,0.0,1.0);
glVertex3d(-1.5,0,1.5);
glEnd();
//CARA2

glShadeModel(GL_SMOOTH);
glBegin(GL_TRIANGLES);
 glColor3f(1.0,0.0,0.0);
glVertex3d(-1.5,0,1.5);
 glColor3f(0.0,1.0,0.0);
glVertex3d(0,3,0);
 glColor3f(0.0,0.0,1.0);
glVertex3d(-1.5,0,-1.5);
glEnd();
//CARA frente
glShadeModel(GL_SMOOTH);
glBegin(GL_TRIANGLES);
 glColor3f(1.0,0.0,0.0);
glVertex3d(-1.5,0,-1.5);
 glColor3f(0.0,1.0,0.0);
glVertex3d(0,3,0);
 glColor3f(0.0,0.0,1.0);
glVertex3d(1.5,0,-1.5);
glEnd();
 //CARA4

glShadeModel(GL_SMOOTH);
glBegin(GL_TRIANGLES);
 glColor3f(1.0,0.0,0.0);
glVertex3d(-1.5,0,1.5);
 glColor3f(0.0,1.0,0.0);
glVertex3d(0,3,0);
 glColor3f(0.0,0.0,1.0);
glVertex3d(1.5,0,1.5);
glEnd();
 //CARA5
 glColor3f(1.0,0.0,1.0);
glBegin(GL_POLYGON);
glVertex3d(-1.5,0,1.5);
glVertex3d(1.5,0,1.5);
glVertex3d(-1.5,0,-1.5);
glVertex3d(1.5,0,-1.5);

glEnd();
glFlush();

}
void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();

    glTranslatef(0.0f, 0.0f, -5.0f);

  
    glRotatef(anguloCuboY, 0.0f, 1.0f, 0.0f);

    drawCube();

    glLoadIdentity();

    glTranslatef(0.0f, 0.0f, -5.0f);
   
    glTranslatef(3.0f, 0.0f, 0.0f);

   
    glFlush();
    glutSwapBuffers();

    anguloCuboX+=0.1f;
    anguloCuboY+=0.1f;
    anguloEsfera+=0.2f;
}
void init()
{
    glClearColor(0,0,0,0);
    glEnable(GL_DEPTH_TEST);
    ancho = 400;
    alto = 400;
}
 
void idle()
{
    display();
}
 
int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(ancho, alto);
    glutCreateWindow("PIRAMIDE");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(idle);
    glutMainLoop();
    return 0;
}

jueves, 18 de octubre de 2012

Esfera girando en su propio eje

#include <GL/glut.h>
GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;
GLint ancho=400;
GLint alto=400;
int hazPerspectiva = 0;
void reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
  
    if(hazPerspectiva)
 gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);
    else
 glOrtho(-4,4, -4, 4, 1, 10);
    glMatrixMode(GL_MODELVIEW);
    ancho = width;
    alto = height;
}
void drawCube(void)
{
    glColor3f(1.0f, 0.0f, 0.0f);
    glBegin(GL_QUADS);       //cara frontal
    glVertex3f(-1.0f, -1.0f,  1.0f);
    glVertex3f( 1.0f, -1.0f,  1.0f);
    glVertex3f( 1.0f,  1.0f,  1.0f);
    glVertex3f(-1.0f,  1.0f,  1.0f);
    glEnd();
    glColor3f(0.0f, 1.0f, 0.0f);
    glBegin(GL_QUADS);       //cara trasera
    glVertex3f( 1.0f, -1.0f, -1.0f);
    glVertex3f(-1.0f, -1.0f, -1.0f);
    glVertex3f(-1.0f,  1.0f, -1.0f);
    glVertex3f( 1.0f,  1.0f, -1.0f);
    glEnd();
    glColor3f(0.0f, 0.0f, 1.0f);
    glBegin(GL_QUADS);       //cara lateral izq
    glVertex3f(-1.0f,-1.0f, -1.0f);
    glVertex3f(-1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f, 1.0f,  1.0f);
    glVertex3f(-1.0f, 1.0f, -1.0f);
    glEnd();
    glColor3f(1.0f, 1.0f, 0.0f);
    glBegin(GL_QUADS);       //cara lateral dcha
    glVertex3f(1.0f, -1.0f,  1.0f);
    glVertex3f(1.0f, -1.0f, -1.0f);
    glVertex3f(1.0f,  1.0f, -1.0f);
    glVertex3f(1.0f,  1.0f,  1.0f);
    glEnd();
    glColor3f(0.0f,      1.0f, 1.0f);
    glBegin(GL_QUADS);       //cara arriba
    glVertex3f(-1.0f, 1.0f,  1.0f);
    glVertex3f( 1.0f, 1.0f,  1.0f);
    glVertex3f( 1.0f, 1.0f, -1.0f);
    glVertex3f(-1.0f, 1.0f, -1.0f);
    glEnd();
    glColor3f(1.0f, 0.0f, 1.0f);
    glBegin(GL_QUADS);       //cara abajo
    glVertex3f( 1.0f,-1.0f, -1.0f);
    glVertex3f( 1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f,-1.0f, -1.0f);
    glEnd();
}
void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    glTranslatef(-3.0f, 0.0f, -5.0f);//mover tres unidades a la izquierda
    glRotatef(anguloCuboX, 1.0f, 0.0f, 0.0f);
    glRotatef(anguloCuboY, 0.0f, 1.0f, 0.0f);
    glScalef(0.5f, 0.5f, 0.5f);//mitad de la esfera
    drawCube();
    glLoadIdentity();
    glTranslatef(-1.0f, 0.0f, -1.0f);
    glRotatef(anguloEsfera, 0.0f, 1.0f, 0.0f);//la esfera gire en  eje y
  glTranslatef(0.0f, 0.0f, 0.0f);
    glColor3f(1.0f, 1.0f, 1.0f);
    glutWireSphere(0.9f, 8, 8);
    glFlush();
    glutSwapBuffers();
    anguloCuboX+=0.1f;
    anguloCuboY+=0.1f;
    anguloEsfera+=0.1f;
}
void init()
{
    glClearColor(0,0,0,0);
    glEnable(GL_DEPTH_TEST);
    ancho = 400;
    alto = 400;
}

void idle()
{
    display();
}
void keyboard(unsigned char key, int x, int y)
{
    switch(key)
    {
    case 'p':
    case 'P':
 hazPerspectiva=1;
 reshape(ancho,alto);
 break;
    case 'o':
    case 'O':
 hazPerspectiva=0;
 reshape(ancho,alto);
 break;
  //  case 27:   // escape
 //exit(0);
    //  break;
    }
}
int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(ancho, alto);
    glutCreateWindow("Cubo 1");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(idle);
    glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}

viernes, 12 de octubre de 2012

Transformaciones









Transformaciones


#include<GL/glut.h>


#include <glut.h>

void trans(void)
{


    glClear (GL_COLOR_BUFFER_BIT);

 glColor3f (0.1, 0.0, 0.1);
 glBegin(GL_POLYGON);
        glVertex3f (2.0, 2.0, 0.0);
        glVertex3f (7.0, 2.0, 0.0);
        glVertex3f (7.0, 7.0, 0.0);
        glVertex3f (2.0, 7.0, 0.0);
 glEnd();


    glColor3f (1.0, 1.0, 1.0);
 glPushMatrix();
 glTranslatef(2.0f,2.0f,0.0f);
    glBegin(GL_POLYGON);
        glVertex3f (2.0, 2.0, 0.0);
        glVertex3f (7.0, 2.0, 0.0);
        glVertex3f (7.0, 7.0, 0.0);
        glVertex3f (2.0, 7.0, 0.0);
    glEnd();
 glPopMatrix();
}

void escal(){


 glColor3f(0.0, 0.0, 0.1);
 glScalef(0.5,0.5,0.0);
  glBegin(GL_POLYGON);
        glVertex3f (2.0, 2.0, 0.0);
        glVertex3f (7.0, 2.0, 0.0);
        glVertex3f (7.0, 7.0, 0.0);
        glVertex3f (2.0, 7.0, 0.0);
    glEnd();


    glFlush ();
}
void rot(void)
{
    glClear (GL_COLOR_BUFFER_BIT);
    glColor3f (0.5, 0.8, 0.2);
 glPushMatrix();
 glRotatef(45,0,0,1);
    glBegin(GL_POLYGON);
        glVertex3f (2.0, 2.0, 0.0);
        glVertex3f (7.0, 2.0, 0.0);
        glVertex3f (7.0, 7.0, 0.0);
        glVertex3f (2.0, 7.0, 0.0);
    glEnd();

 glPopMatrix();

    glFlush ();
}

void init (void)
{
    glClearColor (1.0, 0.0, 0.0, 0.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-15.0, 15.0, -15.0, 15.0, -2.0, 4.0);
}
void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    glTranslatef(0.0f, 0.0f, -5.0f);
    glRotatef(15, 1.0f, 0.0f, 0.0f);
    glRotatef(15, 0.0f, 1.0f, 0.0f);
 
}
void keyboard(unsigned char key, int x, int y)
{
    switch(key)
    {
    case 'p':
    case 'P':
 trans();
 break;
    case 'o':
    case 'O':
 rot();
 break;
    case 'i':
    case 'I':
   escal();
 break;

 
    }
}


int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize (600, 600);
    glutInitWindowPosition (100, 100);
    glutCreateWindow ("proyectox");
    init ();
 
 glutDisplayFunc(rot);
 glutDisplayFunc(trans);
    glutMainLoop();
    return 0;
}








viernes, 5 de octubre de 2012

Proyecto pelota rebota

Algoritmo del programa
·         Inicio del programa
·         Posición actual de la pelota
·         Tamaño de la pelota
·         Tamaño del piso
·         Tamaño de la ventana
·         Dibujar la pelota
·         Dibujar el piso
·         Distancia de rebote del piso hacia arriba
·         Modificar la distancio respecto al piso
·         Saber si esta cállenlo o rebotando
·         Verificar que no pase del piso
·         Dirección de la pelota
·         Disminuir la altura hasta quedar estática en el piso
·         Fin del programa.

Codigo del programa
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#define WIDTH 640
#define HEIGHT 680

  
    void reshape(int width, int height){
    glViewport(0,0,width,height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-WIDTH/2,WIDTH/2-1,-HEIGHT/2,HEIGHT/2-1,-1,1);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    }
       void init(void){
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glPointSize(0.0);
      }
       void Timer(int ex)
    {
    glutPostRedisplay();
    glutTimerFunc(30,Timer,0);
    }
      int k=20;
    void circle(int p,int m)
    {
    int x=0,y,d,r;
    r=m;
    y=r;
    d=3-2*r;
    while(x<=y)
    {
    glVertex2i(-x,y+p);
     glVertex2i(x,y+p);
    glVertex2i(y,x+p);
    glVertex2i(-x,y+p);
    glVertex2i(-y,x+p);
    glVertex2i(-x,-y+p);
    glVertex2i(-y,-x+p);
    glVertex2i(y,-x+p);
   glVertex2i(x,-y+p);
    if(d<0)
    d=d+4*x+6;
    else
    {
    d=d+4*(x-y)+10;
   y--;
    }
    x++;
    }
    }
   int r=100,flag=0;
  
    void display(void)
    {
              typedef GLfloat point2[2];
  point2 vertice[6] = {   {-100.0,-100.0},  {-500.0,-100.0},  {-50.0,50.0},
  {-50.0,50.0},  {100.0,50.0},  {100.0,50.0} };
  glColor3f(0.0,1.0,0.0);
  {
   glClear(GL_COLOR_BUFFER_BIT);
  glBegin(GL_QUADS);
          glVertex2f (-500, -240);
         glVertex2f (0, -100);
          glVertex2f (500, -240);
           glVertex2f (0, -480);
  }
                                 glEnd();

glBegin(GL_LINES);
{
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-100,-130);//1
                glVertex2d(100,-130);
                glColor3f(0.0,0.0,0.0);//
                glVertex2d(-400,-230);
                glVertex2d(400,-230);
               glColor3f(0.0,0.0,0.0);
                glVertex2d(-200,-150);
                glVertex2d(200,-150);
             glColor3f(0.0,0.0,0.0);
                glVertex2d(-270,-170);
                glVertex2d(270,-170);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-310,-190);
                glVertex2d(310,-190);

                glColor3f(0.0,0.0,0.0);
                glVertex2d(-360,-210);
                glVertex2d(360,-210);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-450,-250);
                glVertex2d(450,-250);
              glColor3f(0.0,0.0,0.0);
                glVertex2d(-400,-270);
                glVertex2d(400,-270);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-400,-390);
                glVertex2d(400,-390);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-450,-310);
                glVertex2d(450,-310);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-400,-330);
                glVertex2d(400,-330);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-400,-350);
                glVertex2d(400,-350);
                //verticales
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-0.0,-100);
                glVertex2d(-0.0,-400);

                glColor3f(0.0,0.0,0.0);
                glVertex2d(-50,-50);
                glVertex2d(-50,-400);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-100,-120);
                glVertex2d(-100,-400);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-150,-100);
                glVertex2d(-150,-400);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-200,-80);
                glVertex2d(-200,-400);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-250,-60);
                glVertex2d(-250,-400);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-300,-40);
                glVertex2d(-300,-400);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(-350,-200);
                glVertex2d(-350,-400);
//
                glColor3f(0.0,0.0,0.0);
                glVertex2d(50,-50);
                glVertex2d(50,-400);

                glColor3f(0.0,0.0,0.0);
                glVertex2d(100,-120);
                glVertex2d(100,-400);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(150,-100);
                glVertex2d(150,-400);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(200,-80);
                glVertex2d(200,-400);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(250,-60);
                glVertex2d(250,-400);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(300,-40);
                glVertex2d(300,-400);
                glColor3f(0.0,0.0,0.0);
                glVertex2d(350,-200);
                glVertex2d(350,-400);
                    }

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1.1,0.5,1.0);
    glBegin(GL_POINTS);

    circle(k,r);
  
  
    if(flag==0)
    {
    if((k+r)<=350)
    {
    k=k+10;
  
    }
  
    if((k+r)>=350){
    flag=1;
  
    }
    }
  
    if(flag==1)
    {
    k=k-10;
  
  
    if((k-r)<=-210)
    {
flag=2;
}
    }
                if(flag==2)
    {
    if((k+r)<=300)
    {
    k=k+10;
  
    }
  
    if((k+r)>=300){
    flag=3;
  
    }
    }
                 if(flag==3)
    {
    k=k-10;
  
  
    if((k-r)<=-210)
    {
flag=4;
}
    }
if(flag==4)
    {
    if((k+r)<=200)
    {
    k=k+10;
  
    }
  
    if((k+r)>=200){
    flag=5;
  
    }
    }
if(flag==5)
    {
    k=k-10;
  
  
    if((k-r)<=-210)
    {
flag=6;
                              
}
   
if(flag==6)
{
                k;
 
  
    glEnd();
    glutSwapBuffers();
    }
  
void idle(void){
 
}
  
    int main(int argc, char **argv)
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
glutInitWindowPosition(0,0);
    glutInitWindowSize(WIDTH,HEIGHT);
glutCreateWindow(argv[0]);
init();
glutIdleFunc(idle);
    glutReshapeFunc(reshape);
    glutDisplayFunc(display);
    glutTimerFunc(0,Timer,0);
    glutMainLoop();
    return(1);
    }

Ejecucion del programa