Graficación: 2014

lunes, 24 de marzo de 2014

Programa rotación de figuras

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

GLfloat anio = 0, dia = 0, luna=0, anio2=0, luna2=0, anio3=0, luna3=0;
int angulo_z = 10, opc=0;

void init(void){
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}

void display(void){
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearDepth(1.0);
glColor3f (1.0, 1.0, 0.0);// color del sol
glPushMatrix();

glutSolidSphere(0.7, 20, 16);/* Dibuja el Sol */
glRotatef (angulo_z, 0.0, 0.0, 1.0); //angulo constante de inclinacion en z
glRotatef (anio, 0.0, 1.0, 0.0); //angulo segun el numero de años
glTranslatef (3.0, 0.0, 0.0); //Distancia entre el sol y el primer planeta

glPushMatrix();
glRotatef ( dia, 0.0, 1.0, 0.0); //angulo del planeta segun el dia
glColor3f (0.0, 0.0, 1.0); // color del planeta
glutWireSphere(0.3, 10, 8); /* Dibuja el primer planeta */
glPopMatrix();

glRotatef (25, 0.0, 0.0, 1.0); //Angulo constante de la luna respecto al primer planeta
glRotatef (luna, 0.0, 1.0, 0.0); //Angulo de la luna segun la hora
glTranslatef (0.5, 0.0, 0.0); //Distancia de la luna respecto al primer planeta
glColor3f (0.7, 0.7, 0.7);
glutWireSphere(0.07, 10, 8); // dibuja la luna del primer planeta

glPopMatrix();

glutSwapBuffers();
}

void display2(void){
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearDepth(1.0);
glColor3f (1.0, 1.0, 0.0);// color del sol
glPushMatrix();

glutSolidSphere(0.7, 20, 16);/* Dibuja el Sol */
glRotatef (angulo_z, 0.0, 0.0, 1.0); //angulo constante de inclinacion en z
glRotatef (anio2, 0.0, 1.0, 0.0); //angulo segun el numero de años
glTranslatef (3.0, 1.0, 0.0); //Distancia entre el sol y el primer planeta

glPushMatrix();
glRotatef ( dia, 0.0, 1.0, 0.0); //angulo del planeta segun el dia
glColor3f (1.0, 1.0, 1.0); // color del planeta
glutWireSphere(0.3, 10, 8); /* Dibuja el primer planeta */
glPopMatrix();

glRotatef (25, 0.0, 0.0, 1.0); //Angulo constante de la luna respecto al primer planeta
glRotatef (luna2, 0.0, 1.0, 0.0); //Angulo de la luna segun la hora
glTranslatef (0.5, 0.0, 0.0); //Distancia de la luna respecto al primer planeta
glColor3f (0.7, 0.7, 0.7);
glutWireSphere(0.07, 10, 8); // dibuja la luna del primer planeta

glPopMatrix();

glutSwapBuffers();
}

void display3(void){
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearDepth(1.0);
glColor3f (1.0, 1.0, 0.0);// color del sol
glPushMatrix();

glutSolidSphere(0.7, 20, 16);/* Dibuja el Sol */
glRotatef (angulo_z, 0.0, 0.0, 1.0); //angulo constante de inclinacion en z
glRotatef (anio3, 0.0, 1.0, 0.0); //angulo segun el numero de años
glTranslatef (3.0, -1.0, 0.0); //Distancia entre el sol y el primer planeta

glPushMatrix();
glRotatef ( dia, 0.0, 1.0, 0.0); //angulo del planeta segun el dia
glColor3f (1.0, 0.0, 0.0); // color del planeta
glutWireSphere(0.3, 10, 8); /* Dibuja el primer planeta */
glPopMatrix();

glRotatef (25, 0.0, 0.0, 1.0); //Angulo constante de la luna respecto al primer planeta
glRotatef (luna3, 0.0, 1.0, 0.0); //Angulo de la luna segun la hora
glTranslatef (0.5, 0.0, 0.0); //Distancia de la luna respecto al primer planeta
glColor3f (0.7, 0.7, 0.7);
glutWireSphere(0.07, 10, 8); // dibuja la luna del primer planeta

glPopMatrix();

glutSwapBuffers();
}

void reshape (int w, int h){
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt (0.0, 1.0, 6.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}

void idle()
{
display();
display2();
display3();
}

void keyboard(unsigned char key, int x, int y)
{
switch(key)
{

case 'a':
anio+=1.0f;
break;

case 'A':
luna+=1.5f;
break;

case 's':
anio2+=1.5f;
break;

case 'S':
luna2+=1.5f;
break;

case 'd':
anio3+=1.5f;
break;

case 'D':
luna3+=1.5f;
break;

}
}

int main(int argc, char** argv){
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutDisplayFunc(display2);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

Programa Menus

#include <GL/gl.h>
#include <GL/glut.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>

using namespace std;

#define NP 4000
#define AGE 200

float winWid,winHeight;
float rx,ry;
float pri, seg;
int v[100]={0};
float vrx[100]={0};
float vry[100]={0};
int indi=0;
int b=0;

void menu(int opc)
{

v[indi]=opc;
vrx[indi]=(rx/(winWid/2))-1;
vry[indi]=(ry/(winHeight/2))-1;

switch(v[indi])
{

case 1:

glPushMatrix();
glTranslatef(vrx[indi],vry[indi],0.0);
glColor3f(1.0,0.0,0.0);
glutWireSphere(0.1,15,15);
glPopMatrix();
glFlush();

break;

case 2:

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(vrx[indi],vry[indi],0.0);
glRotatef(55,0,1,1);
glutWireCone(0.1,0.1,15,15);
glPopMatrix();
glFlush();

break;

case 3:

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(vrx[indi],vry[indi],0.0);
glRotatef(55,0,1,1);
glutWireCube(0.1);
glPopMatrix();
glFlush();

break;

case 4:

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(vrx[indi],vry[indi],0.0);
glScalef(0.1,0.1,0.1);
glRotatef(55,0,1,1);
glutWireDodecahedron();
glPopMatrix();
glFlush();

break;

}
}

void dibuja(){
//glClear(GL_COLOR_BUFFER_BIT);

menu(v[indi]);

glutSwapBuffers();
}
// en donde se de clic se movera el punto
void mousebutton(int button, int state, int x, int y)
{
cerr << "mousebutton. x:" << x << ", y:" << y << "\n";
if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN){
rx = float(x);
ry = winHeight - float(y);
indi++;

// redraw();

}
}

int main(int argc, char *argv[]){
winWid = 600.0;
winHeight = 400.0;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
glutCreateWindow(" ");
glutPositionWindow(200,100);
glutReshapeWindow(int(winWid),int(winHeight));
glClearColor(0.0,0.0,0.0,1.0);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

// glutMotionFunc(motion);
glutDisplayFunc(dibuja);
glutIdleFunc(dibuja);
glutMouseFunc(mousebutton);
glutCreateMenu(menu);
glutAddMenuEntry("Opcion 1", 1);
glutAddMenuEntry("Opcion 2", 2);
glutAddMenuEntry("Opcion 3", 3);
glutAddMenuEntry("Opcion 4", 4);
glutAttachMenu(GLUT_RIGHT_BUTTON);

glutMainLoop();

return 0;
}

domingo, 9 de marzo de 2014

Disparo ;)

En este código jugamos un poco con lo que hemos aprendido del uso del teclado. Se muestran dos lineas perpendiculares y al presionar "a" aparece una esfera roja

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

#include <iostream>
#endif
using namespace std;

#include <stdlib.h>

float radio= 0.0;
float valor_x= 0.0;
float m[100]={2.0};
int b=1;
int i=1;

void keyInput(unsigned char key, int x, int y)
{
switch(key){
case 'q':
exit(0);
break;

case 'a':

if(b==0)
{
b=1;
i=i+2;

}

glPushMatrix();
glTranslatef(valor_x,radio,0.0);
glColor3f(1.0,0.0,0.0);
glutWireSphere(0.1,15,15);
glPopMatrix();
glFlush();

m[i-1]=valor_x;

m[i]=radio;

if(b==1)
{
b=0;
}

break;

}
}

void specialkeyInput(int key,int x, int y)
{
if(key==GLUT_KEY_DOWN)
{
if(radio<-1.2)
{
radio=1;
}
else
{
radio-=0.1;
glutPostRedisplay();
}

}
if(key==GLUT_KEY_LEFT)
{
if(valor_x<-1.2)
{
valor_x=1;
}
else
{
valor_x-=0.1;
glutPostRedisplay();
}

}
if(key==GLUT_KEY_UP)
{
if(radio>1.2)
{
radio=-1;

}
radio+=0.1;
glutPostRedisplay();

}
if(key==GLUT_KEY_RIGHT)
{

if(valor_x>1.2)
{
valor_x=-1;

}
else
{
valor_x+=0.1;
glutPostRedisplay();
}

}
}

void dibuja()
{

glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

if(b==0)
{

for(int j=1;j<=i;j=j+2)
{
cerr<<m[j-1];
glPushMatrix();
glColor3f(1.0,0.0,0.0);
glTranslatef(m[j-1],m[j],0.0);
glutWireSphere(0.1,15,15);
glPopMatrix();

}
}

glColor3f(1.0,1.0,0.0);
glBegin(GL_LINES);

glVertex2f(valor_x, 1.0);
glVertex2f(valor_x, -1.0);
glVertex2f(1.0, radio);
glVertex2f(-1.0, radio);
glEnd();
glFlush();

}

int main()
{

cerr << " main() \n";
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(550,550);
glutCreateWindow("");
glutKeyboardFunc(keyInput);
glutDisplayFunc(dibuja);
glutSpecialFunc(specialkeyInput);
glutMainLoop();

}

Cambiar de posición una figura

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

#include <iostream>
#endif
using namespace std;

#include <stdlib.h>

float radio= 0.0;
float valor_x= 0.0;

void keyInput(unsigned char key, int x, int y)
{
switch(key){
case 'q':
exit(0);
break;
}
}

void specialkeyInput(int key,int x, int y)
{
if(key==GLUT_KEY_DOWN)
{
if(radio<-1.2)
{
radio=1;
}
else
{
radio-=0.1;
glutPostRedisplay();
}

}
if(key==GLUT_KEY_LEFT)
{
if(valor_x<-1.2)
{
valor_x=1;
}
else
{
valor_x-=0.1;
glutPostRedisplay();
}

}
if(key==GLUT_KEY_UP)
{
if(radio>1.2)
{
radio=-1;

}
radio+=0.1;
glutPostRedisplay();

}
if(key==GLUT_KEY_RIGHT)
{

if(valor_x>1.2)
{
valor_x=-1;

}
else
{
valor_x+=0.1;
glutPostRedisplay();
}

}
}

void dibuja()
{

glClearColor(0,0,0,0);
glPushMatrix();
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glTranslatef(valor_x,radio,0.0);
glColor3f(1.0,1.0,0.0);
glutWireSphere(0.2,15,15);
glPopMatrix();
glFlush();

}
int main()
{

cerr << " main() \n";
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(550,550);
glutCreateWindow("");
glutKeyboardFunc(keyInput);
glutDisplayFunc(dibuja);
glutSpecialFunc(specialkeyInput);
glutMainLoop();

}

Figuras primitivas GLUT

En este código se muestran la figuras primitivas así como algunas funciones como glRotate (para girar la figura), glTranslate (cambiar de posición la figura) y glutWire y glutSolid que cambia la consistencia de las figuras

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

#include <iostream>
#endif
using namespace std;

#include <stdlib.h>
void dibuja()
{

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(-0.8,0.8,0.0);
glRotatef(45,0,1,1);
glutWireSphere(0.2,15,15);
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(-0.4,0.8,0.0);
glRotatef(55,0,1,1);
glutWireCone(0.2,0.2,15,15);
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(0.0,0.8,0.0);
glRotatef(55,0,1,1);
glutWireCube(0.2);
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(0.4,0.8,0.0);
glScalef(0.1,0.1,0.1);
glRotatef(55,0,1,1);
glutWireDodecahedron();
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(0.8,0.8,0.0);
glScalef(0.2,0.2,0.2);
glRotatef(55,0,1,1);
glutWireIcosahedron();
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(-0.8,0.4,0.0);
glScalef(0.2,0.2,0.2);
glRotatef(55,0,1,1);
glutWireOctahedron();
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(-0.4,0.4,0.0);
glutWireTeapot(0.15);
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(0.05,0.4,0.0);
glScalef(0.2,0.2,0.2);
glRotatef(55,0,1,1);
glutWireTetrahedron();
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(0.4,0.4,0.0);
glRotatef(55,0,1,1);
glutWireTorus(0.1,0.1,15,15);
glPopMatrix();
glFlush();

//SOLIDOS

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(-0.8,0.0,0.0);
glRotatef(45,0,1,1);
glutSolidSphere(0.2,15,15);
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(-0.4,0.0,0.0);
glRotatef(55,0,1,1);
glutSolidCone(0.2,0.2,15,15);
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(0.0,0.0,0.0);
glRotatef(55,0,1,1);
glutSolidCube(0.2);
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(0.4,0.0,0.0);
glScalef(0.1,0.1,0.1);
glRotatef(55,0,1,1);
glutSolidDodecahedron();
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(0.8,0.0,0.0);
glScalef(0.2,0.2,0.2);
glRotatef(55,0,1,1);
glutSolidIcosahedron();
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(-0.8,-0.4,0.0);
glScalef(0.2,0.2,0.2);
glRotatef(55,0,1,1);
glutSolidOctahedron();
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(-0.4,-0.4,0.0);
glutSolidTeapot(0.15);
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(0.05,-0.4,0.0);
glScalef(0.2,0.2,0.2);
glRotatef(55,0,1,1);
glutSolidTetrahedron();
glPopMatrix();
glFlush();

glColor3f(1.0,0.0,0.0);
glPushMatrix();
glTranslatef(0.4,-0.4,0.0);
glRotatef(55,0,1,1);
glutSolidTorus(0.1,0.1,15,15);
glPopMatrix();
glFlush();

}
int main()
{

cerr << " main() \n";
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(550,550);
glutCreateWindow("");
glutDisplayFunc(dibuja);
glutMainLoop();

}

lunes, 17 de febrero de 2014

Generación de cuadrados y triangulos

---Generación de cuadrados---

static void display(void)
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glClear(GL_COLOR_BUFFER_BIT);

glLineWidth(1);//tamaño de la linea

glBegin(GL_QUADS);//se define la figura primitiva a crear

for(float i=-1;i<=1;i+=0.1){

glColor3f(1, i, i);
glVertex2f(-1+i, 1-i);
glVertex2f(1-i, 1-i);
glVertex2f(1-i, -1+i);
glVertex2f(-1+i, -1+i);
}

glEnd();
glFlush();
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600,600);
glutInitWindowPosition(0,0);
glutCreateWindow("Clase 3");
glutDisplayFunc(display);
glutMainLoop();

return EXIT_SUCCESS;
}

---Generación de triángulos---

static void display(void)
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glClear(GL_COLOR_BUFFER_BIT);

glLineWidth(1);//tamaño de la linea

glBegin(GL_TRIANGLES);//se define la figura primitiva a crear

for(float i=-1;i<=1;i+=0.1){

glColor3f(2, i, i);
glVertex2f(0.0, 1-i);
glVertex2f(1-i, -1+i);
glVertex2f(-1+i, -1+i);
}

glEnd();
glFlush();
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600,600);
glutInitWindowPosition(0,0);
glutCreateWindow("Clase 4");
glutDisplayFunc(display);
glutMainLoop();

return EXIT_SUCCESS;
}

Matrices de puntos y lineas

---Código de matrices de puntos---

static void display(void)
{

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glClear(GL_COLOR_BUFFER_BIT);
glPointSize(10);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POINTS);

for(float x=-1.0;x<=1.0;x+=0.1){
for(float y=-1.0;y<=1.0;y+=0.1){

glVertex2f(x, y);

}
}
glEnd();
glFlush();

}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600,600);
glutInitWindowPosition(0,0);
glutCreateWindow("Clase 1");
glutDisplayFunc(display);
glutMainLoop();

return EXIT_SUCCESS;
}

---Código de matrices de lineas---

static void display(void)
{

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glClear(GL_COLOR_BUFFER_BIT);

glLineWidth(1);//tamaño de la linea
glColor3f(1.0,0.0,0.0);//color rojo
glBegin(GL_LINES);//se define la figura primitiva a crear

for(float x=-1.0;x<=1.0;x+=0.1){
for(float y=-1.0;y<=1.0;y+=0.1){

glVertex2f(x, y);
glVertex2f(x, 0.0);
glVertex2f(x, y);
glVertex2f(0.0, y);

}
}

glEnd();
glFlush();
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600,600);
glutInitWindowPosition(0,0);
glutCreateWindow("Clase 2");
glutDisplayFunc(display);
glutMainLoop();

return EXIT_SUCCESS;
}

jueves, 13 de febrero de 2014

Funciones de OpenGL

Descripciones de algunas funciones de OpenGL

glRotated(): cambia la figura de posición

gluInit(): es la función que inicializa la librería GLUT y negocia con el sistema de ventanas la apertura de una nueva ventana

glutInitWindowSize(): se define el tamaño de la ventana en píxeles (anchura y altura)

glutInitWindowPosition(): la distancia horizontal y vertical con respecto de la esquina superior izquierda del monitor donde la ventana deberá aparecer

glutInitDisplayMode(): define el modo en el que se debe dibujar la ventana

glutCreateWindow(): se crea propiamente la ventana, y el string que se pasa como argumento, es utilizado como nombre de la nueva ventana

glutReshapeFunc(). Esta función callback especifica cuál función será llamada cada vez que la ventana sea re dimensionada o movida, pero también es utilizada para definir inicialmente el área de proyección de la figura en la ventana

glutDisplayFunc(display), define que la función display que es pasada como argumento sea ejecutada cada vez que GLUT determine que la ventana debe ser dibujada (la primera vez que se muestra la ventana) o
redibujada (cuando se maximiza, cuando se superponen varias ventanas, etc).

Con las funciones glEnable(GL_CULL_FACE) y glDisable(GL_CULL_FACE) se muestran o se ocultan las líneas de las caras traseras de la figura

Si quieres obtener más información acerca de las funciones de OpenGL dejo estos links

http://sabia.tic.udc.es/gc/Tutorial%20OpenGL/tutorial/cap2.htm
http://www.widget-101.com/opengl/clase-para-el-despliegue-de-texto-en-opengl-y-c/
http://www.tecnun.es/asignaturas/grafcomp/OpenGL/practica/capitulo1.pdf
http://es.scribd.com/doc/11607446/79/glFrustum#page=7

viernes, 7 de febrero de 2014

Elementos del Software (GUI)

GUI - Interfaz Gráfica de Usuario

¿Por qué pensar en Diseño de interfaces Gráficas y Visuales?

- Mejorar elegancia y simplicidad de un producto.
- Aumentar la percepción de valor de un producto, programa o software.
- Mejorar tiempos operativos de usuarios haciendo a la interfaz gráfica más accesible y amigable.
- Mejorar usabilidad y concepto de un sistema de software.

Si quieres saber mas acerca de sus beneficios, conocer su historia y ver sus principales elementos ingresa al link ;)

Presentación :D ;)

Ventajas e implementaciones de la graficación

Link de la presentación ;)