You are on page 1of 9

1,0 Script Comentado

#include <GL/gl.h>
#include <GL/glut.h>
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glPointSize(60);
glBegin(GL_POINTS);
glVertex3f(0.5f,0.5f,0.0f);
glVertex3f(-0.5f,-0.5f,0.0f);
glVertex3f(0.7f,0.7f,0.0f);
glVertex3f(-0.7f,-0.7f,0.0f);
glEnd();
glFlush ();
}
void init (void)
{
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 ("Ejemplo Puntos");
init ();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
Se incluyen las librerías para trabajar con OpenGL

#include <GL/gl.h>
#include <GL/glut.h>

Display(void); es la funcion donde se realizará el objeto, dibujo que


deseamos realizar.

glClear(GL_COLOR_BUFFER_BIT); borra un buffer, o una combinación de


varios, definidos por flags. En este caso, el buffer de colores lo
borra (en realidad, cada componente RGB tiene un buffer distinto).
glPointSize(); Asigna un tamaño de puntos a lo que deseamos dibujar.
glBegin(); Comienza una secuencia de vértices con los que se
construirán las primitivas.

GL_POINTS; Constante primitiva que genera puntos, esperando n


números de vértices.

glVertex3f(); es un vértice en este caso 3D.


glEnd(); cierra la estructura de nuestra figura primitiva.
glFlush(); fuerza la ejecución de comandos GL en tiempo finito.

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glPointSize(60);
glBegin(GL_POINTS);
glVertex3f(0.5f,0.5f,0.0f);
glVertex3f(-0.5f,-0.5f,0.0f);
glVertex3f(0.7f,0.7f,0.0f);
glVertex3f(-0.7f,-0.7f,0.0f);
glEnd();
glFlush ();
}
En la función init() generamos una matriz de proyección para las
configuraciones nuestros ejes coordenados.
glMatrixMode(GL_PROJECTION); especifica qué matriz es la matriz
actual el parámetro aplica las operaciones de matriz subsiguientes a la
pila de la matriz de proyección.
glLoadIdentity(); Carga la matriz identidad.
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); define la perspectiva
ortogonal. Esto quiere decir que los que veremos será una proyección en
uno de los planos definidos por los ejes. Es como plasmar los objetos en
un plano, y luego observar el plano. Los parámetros son para delimitar la
zona de trabajo, y son (xmin, xmax, ymax, ymin, zmin, zmax) en este caso
del código solamente se está mostrando el primer cuadrante de los ejes
x,y.

void init (void)


{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
}

función main es de donde invocamos las funciones de nuestro script; argv


y argc es como se pasan los argumentos de línea de comando main () en C y
C ++.
glutInit(&argc, argv); se usa para inicializar la biblioteca GLUT.
con los paramentos anteriores.
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); establece el modo de
visualización inicial.
GLUT_SINGLE: Máscara de bits para seleccionar una sola ventana
en el búfer.
GLUT_RGB: Máscara de bits para seleccionar una ventana de modo
RGB
glutInitWindowSize (250, 250); establece un tamaño de ventana
parámetros (ancho, alto), para este caso los tamaños de ventana son
250x250.
glutInitWindowPosition (100, 100); posiciona la ventana en (x,y) de
la pantalla. En este caso en la posición 100,100
glutCreateWindow ("Ejemplo Puntos"); Crea un título para la
ventana.
init (); En esta función activamos y definimos una serie de estados
de ogl, antes de pasar el control del programa a la GLUT.

glutDisplayFunc(display); Se define el primer Callback. La funcion


pasada como parámetro será llamada cada vez que el GLUT determine
oportuno que la ventana debe ser redibujada, como al maximizarse,
poner otras ventanas encima o sacarlas, etc.

glutMainLoop(); Cede el control del flujo del programa a la GLUT que


a partir de esos “eventos”, ira llamando a las funciones que han sido
usadas como callbacks.

return 0; indica que se ha concluido satisfactoriamente todas las


instrucciones puesto que retorna un cero, de lo contrario sería un 1.

GLUT: Tiene muchas más posibilidades, por su puesto. Nos ofrece funciones
para el manejo de ratón y teclado, y gran facilidad para la creación de
menús, que permite vincular con un evento como el clic de un ratón o al
presionar una tecla.

int main(int argc, char** argv)


{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (250, 250);
glutInitWindowPosition (100, 100);
glutCreateWindow ("Ejemplo Puntos");
init ();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}
2,0 Script Modificado
#include <GL/gl.h>
#include <GL/glut.h>
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glPointSize(5);
glBegin(GL_LINES);
glVertex3f(-1.0f,0.0f,0.0f);
glVertex3f(1.0f,0.0f,0.0f);
glEnd();
glPointSize(5);
glBegin(GL_LINES);
glVertex3f(0.0f,-1.0f,0.0f);
glVertex3f(0.0f,1.0f,0.0f);
glEnd();
// DIBUJANDO UN CUADRADO PARA COMPROBAR CUADRANTES
glPointSize(10);
glBegin(GL_POLYGON);
glColor3f(1,0.5,0);
glVertex3f(0.5f,0.5f,0.0f);
glVertex3f(-0.5f,0.5f,0.0f);
glVertex3f(-0.5f,-0.5f,0.0f);
glVertex3f(0.5f,-0.5f,0.0f);
glEnd();

glFlush ();

}
void init (void)
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-2,2,-2,2,-2,2);
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (200, 150);
glutInitWindowPosition ((glutGet(GLUT_SCREEN_WIDTH)-
200)/2,(glutGet(GLUT_SCREEN_HEIGHT)-150)/2);
glutCreateWindow ("Ejemplo Puntos");
init ();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

glutGet(GLUT_SCREEN_WIDTH: Obtiene el ancho de la pantalla.


glutGet(GLUT_SCREEN_HEIGHT): obtiene el alto de la pantalla.

*Como queremos que la posicion de la pantalla sera al medio, le restamos el


tamaño de la ventana que iniciaremos.
Dibujo en los cuatro Cuadrantes Alejando el objeto

glOrtho(-1,1,-1,1,-1,1); glOrtho(-2,2,-2,2,-2,2);

Como si estuviese acercando (zoom) la camara

<------ Dibujando en 1er cuadrante

glOrtho(0,1,0,1,-1,1);

Dibujo en el 2do Cuadrante ----->

glOrtho(- 1,0,0,1,-1,1);

<------ Dibujo en el 3er Cuadrante

glOrtho(-1,0,-1,0,-1,1);
Dibujo en el 4to Cuadrante ----->

glOrtho(0,1,-1,0,-1,1);