Graficacion: febrero 2014

Este código es el que muestra el SW Code Blocks como de prueba para observar distintas funciones que se pueden realizar en OpenGL.

/*
* GLUT Shapes Demo
*
* Written by Nigel Stewart November 2003
*
* This program is test harness for the sphere, cone
* and torus shapes in GLUT.
*
* Spinning wireframe and smooth shaded shapes are
* displayed until the ESC or q key is pressed. The
* number of geometry stacks and slices can be adjusted
* using the + and - keys.
*/
//librerias
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glut.h>
#endif
#include <stdlib.h>
//Variables globales
static int slices = 16;/* */
static int stacks = 16;//

/* GLUT callback Handlers */

static void resize(int width, int height)
{
const float ar = (float) width / (float) height;

glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION); //Activar la matriz de proyeccion
glLoadIdentity();
glFrustum(-ar, ar, -1.0, 1.0, 2.0, 100.0);//Definición del volumen de visualizacion
//la matriz de transformacion debe entenderse como una pila
glMatrixMode(GL_MODELVIEW);//activar matriz de trasformación
glLoadIdentity() ;
}

static void display(void)
{
const double t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
const double a = t*90.0;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3d(1,0,0);

//aplicar transformaciones a una pequeña parte de la geometria
glPushMatrix();//se guarda el estado actual de la matriz
//Funcion que nos traslada posiX unidades en el ejeX
//posiY en el eje Y
glTranslated(-2.4,1.2,-6);
//Rotar el angulo segn el eje que define el vector(vx,vy,vz)
glRotated(60,1,0,0);
glRotated(a,0,0,1);
//dibuja la esfera en los puntos que se desea
glutSolidSphere(1,slices,stacks);//Dibuja la esfera solida
glPopMatrix();//se recupera el estado actual de la matriz

glPushMatrix();
//Funcion que nos traslada posiX unidades en el ejeX
//posiY en el eje Y
glTranslated(0,1.2,-6);
//Rotar el angulo segn el eje que define el vector(vx,vy,vz)
glRotated(60,1,0,0);
glRotated(a,0,0,1);
glutSolidCone(1,1,slices,stacks);//dibuja un cono solido
glPopMatrix();

glPushMatrix();
//Funcion que nos traslada posiX unidades en el ejeX
//posiY en el eje Y
glTranslated(2.4,1.2,-6);
//Rotar el angulo segn el eje que define el vector(vx,vy,vz)
glRotated(60,1,0,0);
glRotated(a,0,0,1);
glutSolidTorus(0.2,0.8,slices,stacks);
glPopMatrix();

glPushMatrix();
//Funcion que nos traslada posiX unidades en el ejeX
//posiY en el eje Y
glTranslated(-2.4,-1.2,-6);
//Rotar el angulo segn el eje que define el vector(vx,vy,vz)
glRotated(60,1,0,0);
glRotated(a,0,0,1);
glutWireSphere(1,slices,stacks);//dibuja una esfera sin relleno
glPopMatrix();

glPushMatrix();
//Funcion que nos traslada posiX unidades en el ejeX
//posiY en el eje Y
glTranslated(0,-1.2,-6);
//Rotar el angulo segn el eje que define el vector(vx,vy,vz)
glRotated(60,1,0,0);
glRotated(a,0,0,1);
glutWireCone(1,1,slices,stacks);//dibuja un cono sin relleno
glPopMatrix();

glPushMatrix();
//Funcion que nos traslada posiX unidades en el ejeX
//posiY en el eje Y
glTranslated(2.4,-1.2,-6);
//Rotar el angulo segn el eje que define el vector(vx,vy,vz)
glRotated(60,1,0,0);
glRotated(a,0,0,1);
glutWireTorus(0.2,0.8,slices,stacks);//dibuja una dona sin relleno
glPopMatrix();

glutSwapBuffers();
}

//metodo que controla la animación del movimiento de las figuras
static void key(unsigned char key, int x, int y)
{
switch (key)
{
case 27 :
case 'q':
exit(0);
break;

case '+':
slices++;
stacks++;
break;

case '-':
if (slices>3 && stacks>3)
{
slices--;
stacks--;
}
break;
}

glutPostRedisplay();
}

static void idle(void)
{
glutPostRedisplay();
}

const GLfloat light_ambient[] = { 0.0f, 0.0f, 0.0f, 1.0f };
const GLfloat light_diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat light_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat light_position[] = { 2.0f, 5.0f, 5.0f, 0.0f };

const GLfloat mat_ambient[] = { 0.7f, 0.7f, 0.7f, 1.0f };
const GLfloat mat_diffuse[] = { 0.8f, 0.8f, 0.8f, 1.0f };
const GLfloat mat_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat high_shininess[] = { 100.0f };

/* Program entry point */

int main(int argc, char *argv[])
{
glutInit(&argc, argv);//recoger los parametros de la linea de comandos
glutInitWindowSize(640,480);//define tamaño de la ventana ancho y alto
//colocar la ventana en un punto determinador de la pantalla, origenx,origeny
glutInitWindowPosition(10,10);
//le dice al motor grafico que hay que renderizar, refrescar
//o no la pantalla, que buffer hay que activar o desactivar y
//la modalidad de colores que queremos usar
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

//crear la ventana con un titulo<-se pasa a un array de caracteres
glutCreateWindow("GLUT Shapes");

////manda llamar el metodo a ejecutar
glutReshapeFunc(resize);
//el sistema le dice al subsistema grafico cal es la funcion que
//que debe llamarse cada vez que se requiera dibujar de nuevo en pantalla
glutDisplayFunc(display);
glutKeyboardFunc(key);
glutIdleFunc(idle);

glClearColor(1,1,1,1);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);

glEnable(GL_LIGHT0);//activar o desactivar la luz 0
glEnable(GL_NORMALIZE);//activa la normalizacion
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_LIGHTING);//activar y desactivar todo el cálculo de iluminación

//Colocar un foco en un lugar determinado
//GL_LIGHT0, GL_LIGHT1, GL_LIGHT2
//parametros RGBA rales, definien el porcentaje de intensidad
//de cada color que tiene la luz.
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);

//
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
//definimos que todas las caras principales
//FRONT son las caras "que se ven" del poligono
//los componentes dibujados ahora tendrán una componente difu
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);

//Es entrar al bucle infinito que domina cualquier aplicacion
//OpenGL y con la sig. funcion se le dice a la libreria que
//espere eternamenta que se produzcan "eventos"
glutMainLoop();

return EXIT_SUCCESS;
}

Este es el primer código que eh realizado, consiste en dibujar puntos en un plano 2D. Cabe destacar el uso de la primitiva GL_POINTS.

//librerias
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glut.h>
#endif
#include <stdlib.h>

/* GLUT callback Handlers */

static void display(void)
{

//glClearColor(0,0,1,1);//color de pantalla
glClear(GL_COLOR_BUFFER_BIT);//limpia la pantalla
glPointSize(10);//Grosor del punto
glColor3f(1,0.1,0.0);//color rojo (RGB) para los elementos dibujados dentro del glBegin()
//GLBegin se utiliza para encapsular o escribir toda primitiva
//GL_POINTS se utiliza para dibujar puntos individuales
glBegin(GL_POINTS);
//controla x
for(double i=-1.0;i<1.0;i=i+0.1){
//controla y
for(double j=-1.0; j<1.0;j=j+0.1){
glVertex2d(i,j);
}
}

glEnd();//cierra glBegin()
glFlush();//refuerzo de pintado
}

int main(int argc, char *argv[])
{
glutInit(&argc, argv);//recoger los parametros de la linea de comandos
//le dice al motor grafico que hay que renderizar, refrescar
//o no la pantalla, que buffer hay que activar o desactivar y
//la modalidad de colores que queremos usar
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600,600);//establece el tamaño de la pantalla donde se mostrará nuestro dibujo o animacion
glutInitWindowPosition(0,0);//establecen las coordenadas del lugar de la pantalla donde se quiere que aparezca la ventana
glutCreateWindow("Dibuja Puntos");//Titulo de la Ventana
glutDisplayFunc(display);//manda llamar el metodo a ejecutar
//Es entrar al bucle infinito que domina cualquier aplicacion
//OpenGL y con la sig. funcion se le dice a la libreria que
//espere eternamenta que se produzcan "eventos"
glutMainLoop();

}

Este segundo código muestra como dibujar una cuadricula en un plano 2D. Cabe resaltar ahora el uso de la primitiva GL_LINES_STRIP.

//librerias
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glut.h>
#endif
#include <stdlib.h>

/* GLUT callback Handlers */

static void display(void)
{
glClearColor(1.0,1.0,0.0,1.0);//color de pantalla
glClear(GL_COLOR_BUFFER_BIT);//limpia la pantalla
glLineWidth(7);//define el grosor de linea
glColor3f(0.0,0.0,1.0);//color azul fuerte (RGB) para los elementos dibujados dentro del glBegin()
//GLBegin se utiliza para encapsular o escribir toda primitiva
//GL_LINE_STRIP permite trazar series de segmentos conectados
glBegin(GL_LINE_STRIP);
//primer for dibuja las lineas verticales
//controla y
double j=1.0;
//controla x
for(double i=-0.1;i<=1.0;i=i+0.1){
glVertex2d(i,j);// dibuja un vertice en la coordenada (x,y)
glVertex2d(i,-j);
glVertex2d(-i,-j);
glVertex2d(-i,j);
}
//segundo for dibuja las lineas horizontales
//controla x
double i=1.0;
//controla y
for(double j=-1.0;j<=1.0;j=j+0.1){
glVertex2d(-i,j);// dibuja un vertice en la coordenada (x,y)
glVertex2d(-i,-j);
glVertex2d(i,-j);
glVertex2d(-i,-j);
//glColor3f(1.0,1.0,0.0);
//glVertex2d(i,-j);

}

glEnd();//cierra glBegin()
glFlush();//refuerzo de pintado

}

int main(int argc, char *argv[])
{
glutInit(&argc, argv);//recoger los parametros de la linea de comandos
//le dice al motor grafico que hay que renderizar, refrescar
//o no la pantalla, que buffer hay que activar o desactivar y
//la modalidad de colores que queremos usar
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600,600);//establece el tamaño de la pantalla donde se mostrará nuestro dibujo o animacion
glutInitWindowPosition(50,50);//establecen las coordenadas del lugar de la pantalla donde se quiere que aparezca la ventana
glutCreateWindow("Dibuja Cuadricula");//Titulo de la Ventana
glutDisplayFunc(display);//manda llamar el metodo a ejecutar
//Es entrar al bucle infinito que domina cualquier aplicacion
//OpenGL y con la sig. funcion se le dice a la libreria que
//espere eternamenta que se produzcan "eventos"
glutMainLoop();

}

Este tercer código muestra como dibujar un cuadrado con cuadrados dibujados sobre él. Cabe resaltar ahora el uso de la primitiva GL_QUADS.

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glut.h>
#endif

#include <stdlib.h>

static void display(void)
{
float a=1.0;
//glClearColor(1.0,1.0,0.0,1.0);//color de pantalla
glClear(GL_COLOR_BUFFER_BIT);//limpia la pantalla
glPointSize(10);//Grosor del punto
//GLBegin se utiliza para encapsular o escribir toda primitiva
//GL_QUADS permite que cada cuadrupla de vertices determine un cuadrado
glBegin(GL_QUADS);

for(double i=1.0;i>=0.1;i=i-0.1){
glColor3f(0.0,a,1.0);//color azul marino/cian(RGB) para los elementos dibujados dentro del glBegin()
glVertex2d(-i,-i);
glVertex2d(-i,i);
glVertex2d(i,i);
glVertex2d(i,-i);
if(a==1.0){
a=a-1;
}else{
a=a+1;
}

}
/*Cuadrado
glVertex2d(-0.1,-0.1);
glVertex2d(-0.1,0.1);
glVertex2d(0.1,0.1);
glVertex2d(0.1,-0.1);*/

glEnd();//cierra glBegin()
glFlush();//refuerzo de pintado

}

int main(int argc, char *argv[])
{
glutInit(&argc, argv);//recoger los parametros de la linea de comandos
//le dice al motor grafico que hay que renderizar, refrescar
//o no la pantalla, que buffer hay que activar o desactivar y
//la modalidad de colores que queremos usar
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600,600);//establece el tamaño de la pantalla donde se mostrará nuestro dibujo o animacion
glutInitWindowPosition(0,0);//establecen las coordenadas del lugar de la pantalla donde se quiere que aparezca la ventana
glutCreateWindow("Dibuja Cuadrado");//Titulo de la Ventana
glutDisplayFunc(display);//manda llamar el metodo a ejecutar
//Es entrar al bucle infinito que domina cualquier aplicacion
//OpenGL y con la sig. funcion se le dice a la libreria que
//espere eternamenta que se produzcan "eventos"
glutMainLoop();

}

Este cuarto código muestra como dibujar un triangulo con triangulo dibujados sobre él. Cabe resaltar ahora el uso de la primitiva GL_TRIANGLES.

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glut.h>
#endif

#include <stdlib.h>

static void display(void)
{
float a=1.0;
//glClearColor(1.0,1.0,0.0,1.0);//color de pantalla
glClear(GL_COLOR_BUFFER_BIT);//limpia la pantalla
glPointSize(10);//Grosor del punto
//GLBegin se utiliza para encapsular o escribir toda primitiva
//GL_TRIANNGLES permite que cada terna de vertices determine un triangulo
glBegin(GL_TRIANGLES);

for(double i=1.0;i>=0.1;i=i-0.1){
glColor3f(1.0,a,0.0);//color amarillo/rojo (RGB) para los elementos dibujados dentro del glBegin()
glVertex2d(-i,-i);
glVertex2d(0.0,i);
glVertex2d(i,-i);
if(a==1.0){
a=a-1;
}else{
a=a+1;
}

}
/*Triangulo
glVertex2d(-0.1,-0.1);
glVertex2d(0.0,0.1);
glVertex2d(0.1,-0.1);*/

glEnd();//cierra glBegin()
glFlush();//refuerzo de pintado

}

int main(int argc, char *argv[])
{
glutInit(&argc, argv);//recoger los parametros de la linea de comandos
//le dice al motor grafico que hay que renderizar, refrescar
//o no la pantalla, que buffer hay que activar o desactivar y
//la modalidad de colores que queremos usar
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600,600);//establece el tamaño de la pantalla donde se mostrará nuestro dibujo o animacion
glutInitWindowPosition(0,0);//establecen las coordenadas del lugar de la pantalla donde se quiere que aparezca la ventana
glutCreateWindow("Dibuja Cuadrado");//Titulo de la Ventana
glutDisplayFunc(display);//manda llamar el metodo a ejecutar
//Es entrar al bucle infinito que domina cualquier aplicacion
//OpenGL y con la sig. funcion se le dice a la libreria que
//espere eternamenta que se produzcan "eventos"
glutMainLoop();
}

Graficacion

viernes, 28 de febrero de 2014

Figuras con alambres y solidas

lunes, 17 de febrero de 2014

Programas en CODE BLOCKS utilizando OpenGL

OpenGL vs DirectX

Presentación en Power Point de las distintas Aplicaciones gráficas por computadora