#include <stdafx.h>

#include <stdlib.h>

#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(0.0f, 0.0f, -5.0f);

    //glRotatef(anguloCuboX, 1.0f, 0.0f, 0.0f);

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

    drawCube();

    glLoadIdentity();

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

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

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

    glColor3f(1.0f, 1.0f, 1.0f);

    glutWireSphere(0.5f, 8, 8);

    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();

}

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;

}

Conceptos Aspect Ratio, Viewports y Pipeline Grafico

Investigar los siguientes conceptos:

Aspect ratio:
La relación de aspecto, ratio, ratio de aspecto, proporción de aspecto o razón de aspecto (traducciones literales de la expresión en inglés aspect ratio) de una imagen es la proporción entre su ancho y su altura. Se calcula dividiendo el ancho por la altura de la imagen visible en pantalla, y se expresa normalmente como «X:Y».

Viewports o visor: 
Un viewport es una región rectangular visualización en gráficos de computadora, o un término utilizado para los componentes ópticos. Ventana de recorte o de visualizacion.

Pipeline Grafico: 
Para llevar a cabo una representación virtual de un ambiente tridimensional, se realiza un modelado del escenario. Dicho modelo incluye la representación geométrica de los objetos presentes, las condiciones de iluminación de la escena y el lugar dentro de la misma desde dónde es apreciada. Cada objeto es representado a través de combinaciones, más o menos complejas, de figuras geométricas, el color o las texturas de sus superficies, y su posición y orientación en la escena. Luego se configuran las condiciones de iluminación, es decir posición, color, tipo y demás atributos de cada fuente de luz presente en la escena. Por último, se determina la posición y dirección del punto de vista o de la cámara a través de la cual se visualiza el ambiente. La visualización del ambiente en un dispositivo, como la pantalla de un monitor, es posible gracias a software y hardware especializado. Dicha especialización permite dibujar eficientemente sobre una pantalla bidimensional la proyección, comúnmente en perspectiva, de una escena tridimensional.
Pipeline de OpenGL: 
La mayoría de las implementaciones de OpenGL tienen un orden similar de operaciones, una serie de etapas de procesamiento de llamada de la canalización de representación de OpenGL.Este orden, como se muestra en la Figura , no es una regla estricta de cómo se implementa OpenGL, pero proporciona una guía confiable para predecir lo que va a hacer OpenGL.
--------------------------------------------------------------------------------------------------------------------------------

PRISMA TRIANGULAR ROTACION

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

GLfloat   angX=0.0f;
GLfloat   angY=0.0f;

void reshape( int width, int height)
{
glViewport(0,0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-13,17,-15,15,-15,15);
glMatrixMode(GL_MODELVIEW);
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
glLoadIdentity();

glRotatef(angX,1,0,0);
glRotatef(angY,0,1,0);

glBegin(GL_TRIANGLES);
glColor3f(1.0,0.0,0.0);
glVertex3f(0,0,0);
glVertex3f(0,0,3);
glVertex3f(1.5,3,1.5);
glVertex3f(0,0,0);
glEnd();
glBegin(GL_TRIANGLES);
glColor3f(0.0,1.0,0.0);
glVertex3f(3,0,0);
glVertex3f(3,0,3);
glVertex3f(1.5,3,1.5);
glVertex3f(3,0,0);
glEnd();
glBegin(GL_TRIANGLES);
glColor3f(0.0,0.0,1.0);
glVertex3f(0,0,3);
glVertex3f(3,0,3);
glVertex3f(1.5,3,1.5);
glVertex3f(0,0,3);
glEnd();
glBegin(GL_TRIANGLES);
glColor3f(1.0,1.0,0.0);
glVertex3f(0,0,0);
glVertex3f(3,0,0);
glVertex3f(1.5,3,1.5);
glVertex3f(0,0,0);
glEnd();

glBegin(GL_POLYGON);
glColor3f(1.0,0.0,1.0);
glVertex3f(0,0,0);
glVertex3f(3,0,0);
glVertex3f(3,0,3);
glVertex3f(0,0,3);
glEnd();

glFlush();
glutSwapBuffers();
    angX+=0.1f;
    angY+=0.1f;
}
 void init()
{
glClearColor(0,0,0,0);
//glEnable(GL_DEPTH_TEST);
}

void idle()
{
    display();
}

int main (int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(50,50);
glutInitWindowSize(500,500);
glutCreateWindow("PRISMA TRIANGULAR");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutMainLoop();
return 0;
}

CODIGO CREACION DEL PRISMA

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

void reshape( int width, int height)
{
glViewport(0,0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-3,7,-5,5,-5,5);
glMatrixMode(GL_MODELVIEW);
}

void display()

{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
glLoadIdentity();

glBegin(GL_TRIANGLES);

glColor3f(1.0,0.0,0.0);
glVertex3f(0,0,0);
glVertex3f(0,0,3);
glVertex3f(1.5,3,-1.5);
glVertex3f(0,0,0);
glEnd();

glBegin(GL_TRIANGLES);
glColor3f(0.0,1.0,0.0);
glVertex3f(3,0,0);
glVertex3f(3,0,3);
glVertex3f(1.5,3,-1.5);
glVertex3f(3,0,0);
glEnd();

glBegin(GL_TRIANGLES);
glColor3f(0.0,0.0,1.0);
glVertex3f(0,0,3);
glVertex3f(3,0,3);
glVertex3f(1.5,3,-1.5);
glVertex3f(0,0,3);
glEnd();
glBegin(GL_TRIANGLES);
glColor3f(1.0,1.0,0.0);
glVertex3f(0,0,0);
glVertex3f(3,0,0);
glVertex3f(1.5,3,-1.5);
glVertex3f(0,0,0);
glEnd();

glBegin(GL_POLYGON);
glColor3f(1.0,0.0,1.0);
glVertex3f(0,0,0);
glVertex3f(3,0,0);
glVertex3f(3,0,3);
glVertex3f(0,0,3);
glEnd();

glFlush();

}

void init()
{
glClearColor(0,0,0,0);
}

int main (int argc, char **argv)

{

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(50,50);
glutInitWindowSize(500,500);
glutCreateWindow("PRISMA TRIANGULAR");

init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

9.- VECTOR Y RASTER

Formatos  son de imagen rasterizada y que formatos de imagen vetorial

La apariencia de los píxeles en una imagen después de una transformación geométrica (en particular cuando se la amplía) se denomina pixelación (también conocida como efecto escalonado). Además, las imágenes vectoriales  permiten definir una imagen con muy poca información, por lo que los archivos son bastante pequeños.

Por otra parte, una imagen vectorial sólo permite la representación de formas simples. Si bien es verdad que la superposición de varios elementos simples puede producir resultados impresionantes, no es posible describir todas las imágenes con vectores; éste es particularmente el caso de las fotografías realistas.

Imagen bitmap: como su nombre indica esta basada en un mapa de bits. Esto significa que cada bit (mínima unidad de información en este caso el píxel) se puede manipular individualmente. Así son imágenes que contienen más cantidad de información y por tanto más megas que las vectoriales. Los formatos de estas imágenes son, entre otros, jpg, tif o bmp. Y los programas actos para manipularlas son, por ejemplo, el gimp o el photoshop.

Imagen vectorial: Las imágenes vectoriales se construyen a partir de vectores. Los vectores son objetos formados matemáticamente. Un vector se define por una serie de puntos que tienen unas manecillas con las que se puede controlar la forma de la línea que crean al estar unidos entre sí. Los principales elementos de un vector son las curvas Béizer (curvas representadas matemáticamente).
Por tanto se basan en fórmulas matemáticas y superficies de color plano o que siguen una norma, como por ejemplo un degradado.

vectorial	mapa de bits

Imagen Rasterizada

Una imagen rasterizada esta compuesta de finos puntos llamados pixeles. Cuando estos pixeles son pequeños y puestos muy juntos, estos engañan al ojo y se ven como una imagen completa.
Las imágenes rasterizadas trabajan bien cuando subtle gradations de color son necesarias.

Imágenes vectoriales e imágenes de mapa de bits

imágenes vectoriales: las imágenes vectoriales son representaciones de entidades geométricas tales como círculos, rectángulos o segmentos. Están representadas por fórmulas matemáticas (un rectángulo está definido por dos puntos; un círculo, por un centro y un radio; una curva, por varios puntos y una ecuación). El procesador "traducirá" estas formas en información que la tarjeta gráfica pueda interpretar.

Dado que una imagen vectorial está compuesta solamente por entidades matemáticas, se le pueden aplicar fácilmente transformaciones geométricas a la misma (ampliación, expansión, etc.), mientras que una imagen de mapa de bits, compuesta por píxeles, no podrá ser sometida a dichas transformaciones sin sufrir una pérdida de información llamada distorsión. 

8.- CUBO EN 2D

----------------------------------------------

                CUBO EN 2D

----------------------------------------------

#include "stdafx.h"

#include <GL/glut.h>
void reshape( int width, int height)
{
glViewport(0,0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-3,7,-5,5,-5,5);
glMatrixMode(GL_MODELVIEW);
}

void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1,1,1);
glLoadIdentity();
glBegin(GL_LINE_LOOP);
glVertex2f(0,0);
glVertex2f(3,0);
glVertex2f(3,-3);
glVertex2f(0,-3);
glVertex2f(0,0);
glVertex2f(-2,1);
glVertex2f(-2,-2);
glVertex2f(0,-3);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2f(3,0);
glVertex2f(1,1);
glVertex2f(-2,1);
glVertex2f(-2,-2);
glVertex2f(1,-2);
glVertex2f(1,1);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2f(1,-2);
glVertex2f(3,-3);

glEnd();
glFlush();
}

void init()
{
glClearColor(0,0,0,0);
}
int main (int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(50,50);
glutInitWindowSize(500,500);
glutCreateWindow("CUBO 2D");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

7.- PRISMA TRIANGULAR

--------------------------------------------------------------

                  PRISMA TRIANGULAR

--------------------------------------------------------------

#include <stdlib.h>

#include <GL/glut.h>

void reshape( int width, int height)

{

glViewport(0,0, width, height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

glOrtho(-3,7,-5,5,-5,5);

glMatrixMode(GL_MODELVIEW);

}

void display()

{

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(1.0,0.0,0.0);

glLoadIdentity();

glBegin(GL_TRIANGLES);

glColor3f(1.0,0.0,0.0);

glVertex3f(0,0,0);

glVertex3f(0,0,3);

glVertex3f(1.5,3,-1.5);

glVertex3f(0,0,0);

glBegin(GL_TRIANGLES);

glColor3f(0.0,1.0,0.0);

glVertex3f(3,0,0);

glVertex3f(3,0,3);

glVertex3f(1.5,3,-1.5);

glVertex3f(3,0,0);

glBegin(GL_TRIANGLES);

glColor3f(0.0,0.0,1.0);

glVertex3f(0,0,3);

glVertex3f(3,0,3);

glVertex3f(1.5,3,-1.5);

glVertex3f(0,0,3);

glBegin(GL_TRIANGLES);

glColor3f(1.0,1.0,0.0);

glVertex3f(0,0,0);

glVertex3f(3,0,0);

glVertex3f(1.5,3,-1.5);

glVertex3f(0,0,0);

glEnd();

glFlush();

}

 void init()

{

glClearColor(0,0,0,0);

}

int main (int argc, char **argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

glutInitWindowPosition(50,50);

glutInitWindowSize(500,500);

glutCreateWindow("PRISMA TRIANGULAR");

init();

glutDisplayFunc(display);

glutReshapeFunc(reshape);

glutMainLoop();

return 0;

}