Sintaxis básica de OpenGL

A continuación se muestra un programa de ejemplo que se encuentra en las librerias del programa Code::Blocks:

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

/*

 Alumno: Sáenz Morales Carlos Giovanni

 */

#ifdef __APPLE__

#include <GLUT/glut.h>

#else

#include <GL/gl.h> //es una libreria

#include <GL/glut.h>

#endif

#include <stdlib.h>

//Estas dos lineas definen el contorno de la figura

//mientras más grande es, más suave son los bordes de la figura

//Deben estar iguales para que se mantenga la forma

static int slices = 30;

static int stacks = 30;

/* GLUT callback Handlers */

static void resize(int width, int height)//cambia el tamaño de las imagenes

{

    const float ar = (float) width / (float) height;

    glViewport(0, 0, width, height);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glFrustum(-ar, ar, -1.0, 1.0, 2.0, 100.0);

    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity() ;

}

static void display(void)

{

    //Estas lineas modifican el tiempo de giro

    const double t = glutGet(GLUT_ELAPSED_TIME) / 1000.0; //numero de segundos

        const double a = t*90.0;

    //Estas lineas dan los colores, el color esta dado como ROJO , VERDE , AZUL

    //Mientras más grande es el número, más claro es el color

    //No entiendo en qué formato se da

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glColor3d(0,0,1);//modifica el color en formato rgb y con valor doble

    //Esfera rellena

    glPushMatrix();

        //Esta linea posiciona la figura en la pantalla (x, y, z)

        glTranslated(-2.5,1.2,-6);

        //Esta linea da la inclinacion que tendrá la figura

        glRotated(60,1,0,0);

        //Esta linea establiza la figura para que se mantenga en una posicion fija

        glRotated(a,0,0,1);

        //Esta linea determina el tamaño de la figura y la gradilla que la formará

        glutSolidSphere(1,slices,stacks);//crea una esfera solida

    glPopMatrix();

    //Las mismas instrucciones son para las siguientes figuras.

    //Cono relleno

    glPushMatrix();

        glTranslated(0,1.2,-6);

        glRotated(60,1,0,0);

        glRotated(a,0,0,1);

        glutSolidCone(1,1,slices,stacks); //crea un cono rellena

    glPopMatrix();

    //Dona rellena

    glPushMatrix();

        glTranslated(2.4,1.2,-6);

        glRotated(60,1,0,0);

        glRotated(a,0,0,1);

        glutSolidTorus(0.2,0.8,slices,stacks); //crea una dona rellena

    glPopMatrix();

    //Esfera hueca

    glPushMatrix();

        glTranslated(-2.4,-1.2,-6);

        glRotated(60,1,0,0);

        glRotated(a,0,0,1);

        glutWireSphere(1,slices,stacks); //dibuja una esfera solamente con lineas

    glPopMatrix();

    //Cono hueco

    glPushMatrix();

        glTranslated(0,-1.2,-6);

        glRotated(60,1,0,0);

        glRotated(a,0,0,1);

        glutWireCone(1,1,slices,stacks);

    glPopMatrix();

    //Dona hueca

   glPushMatrix();

        glTranslated(2.4,-1.2,-6);

        glRotated(60,1,0,0);

        glRotated(a,0,0,1);

        glutWireTorus(0.2,0.8,slices,stacks);

    glPopMatrix();

    glutSwapBuffers();

}

//Con este metodo se permite cambiar el numero de lineas en la gradilla

//con los botones + y - del teclado, asi como de salir mediante la tecla q

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

    //Esta determina el tamaño de la ventana por default

    glutInitWindowSize(700,540);

    //Esta linea posiciona la ventana en la pantalla

    glutInitWindowPosition(300,300);

    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

    glutCreateWindow("GLUT Shapes");

    //La linea siguiente es para redimensionar las figuras cuando se cambia el tamaño de la ventana

    glutReshapeFunc(resize);

    glutDisplayFunc(display);

    glutKeyboardFunc(key);

    glutIdleFunc(idle);

    //La siguiente linea establece el color de fondo de la pantalla (Rojo, verde, azul, alpha)

    glClearColor(0,1,0,0);

    glEnable(GL_CULL_FACE);

    glCullFace(GL_BACK);

    glEnable(GL_DEPTH_TEST);

    glDepthFunc(GL_LESS);

    glEnable(GL_LIGHT0);

    glEnable(GL_NORMALIZE);

    glEnable(GL_COLOR_MATERIAL);

    glEnable(GL_LIGHTING);

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

    glMaterialfv(GL_FRONT, GL_DIFFUSE,   mat_diffuse);

    glMaterialfv(GL_FRONT, GL_SPECULAR,  mat_specular);

    glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);

    glutMainLoop();

    return EXIT_SUCCESS;

}

OpenGL

Práctica con el software Code::Blocks

Practica 1 - Generación de cuadrados con la función GL_QUADS

El siguiente código nos ayudará a desplegar en nuestra pantalla un juego de cuadrados que varían de tonalidad en grises de blanco a negro conforme se acercan al centro, es necesario implementar las librerías necesarias antes de ejecutar el programa:

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

#ifdef __APPLE__

#include <GLUT/glut.h>

#else

#include <GL/gl.h>

#include <GL/glut.h>

#endif

#include <stdlib.h>

void display(void){

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glClear(GL_COLOR_BUFFER_BIT);

    //glPointSize(2);

    //glLineWidth(2);

    //glColor3f(1.0, 0.0, 0.0);

    double i=0.9;

    float k=1.0;

//Cuadrados

        glBegin(GL_QUADS);

            for(i;i>0.1;i=i-0.1){

                    glColor3f(k,k,k);

                    glVertex2d(i,i);

                    glVertex2d(i*-1,i);

                    glVertex2d(i*-1,i*-1);

                    glVertex2d(i,i*-1);

                    k=k-0.1;

            }

        glEnd();

    glFlush();

}

int main (int argc, char** argv){

    glutInit(&argc,argv);

    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

    glutInitWindowSize(600, 600);

    glutInitWindowPosition(0, 0);

    glutCreateWindow("Matriz");

    glutDisplayFunc(display);

    glutMainLoop();

}

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

Esto producirá una imagen como la siguiente:

Practica 2 - Generación de triángulos con función GL_TRIANGLE

De igual manera, se pueden generar una serie de triángulos con el mismo método utilizado para los cuadrados, a continuación se presenta el siguiente ejemplo:

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

#ifdef __APPLE__

#include <GLUT/glut.h>

#else

#include <GL/gl.h>

#include <GL/glut.h>

#endif

#include <stdlib.h>

void display(void){

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glClear(GL_COLOR_BUFFER_BIT);

    //glPointSize(2);

    //glLineWidth(2);

    //glColor3f(1.0, 0.0, 0.0);

    double i=0.9;

    float k=1.0;

//Cuadrados

        glBegin(GL_TRIANGLES);

         for(i;i>0.1;i=i-0.1){

                    glColor3f(k,k,k);

                    glVertex2d(0,i);

                    glVertex2d(i,i*-1);

                    glVertex2d(i*-1,i*-1);

                    k=k-0.1;

         }

        glEnd();

    glFlush();

}

int main (int argc, char** argv){

    glutInit(&argc,argv);

    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

    glutInitWindowSize(600, 600);

    glutInitWindowPosition(0, 0);

    glutCreateWindow("Matriz");

    glutDisplayFunc(display);

    glutMainLoop();

}

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

En este caso, obtendremos una imagen como la que a continuación se muestra:

Sáenz Morales Carlos

Graficación por computadora

 La computación gráfica o gráficos por ordenador es el campo de la informática visual, donde se utilizan computadoras tanto para generar imágenes de manera sintética así como integrar o cambiar la información visual y especial probada del mundo real.


Este campo puede ser dividido en varias áreas:•Interpretando en 3D en tiempo real (usado en juegos de video).•Animación por computadora. •Captura de video y creación de video interpretado. •Edición de efectos especiales (a menudo usado para películas y televisión).•Edición de imagen y modelo (usado para ingeniería y objetivos médicos).


Actualmente existe un sinfín de aplicaciones por mecinar algunas de las más importante, podemos citar:

Diseño asistido por computadora
Este método, también llamado generalmente como CAD (Computer Assisted Desing) ahora se utiliza de forma habitual para el diseño de construcciones, automóviles, aeronaves, embarcaciones, etc.


Arte por computadora
Los artistas utilizan una variedad de métodos computacionales, incluyendo hardware para propósitos especiales, programas artísticos de brocha de pintar del artista (como Lumena), otros paquetes de pintura y paquetes de animaciones que proporcionan los medios para diseñar formas de objetos y especificar movimientos de objetos.


Entretenimiento
Hoy en día es muy común utilizar métodos de gráficas por computadora para producir películas, videos musicales y programas de televisión. En ocasiones, se despliegan sólo imágenes gráficas y otras veces, se combinan los objetos con los actores y escenas en vivo. 


Educación y capacitación
A menudo, se utilizan como instrumentos de ayuda educativa modelos de sistemas físicos, financieros y económicos, los cuales se generan por computadora.

Visualización 
Científicos, ingenieros, personal médico, analistas comerciales y otros con frecuencia necesitan analizar grandes cantidades de información o estudiar el comportamiento de ciertos procesos.

A continuación, se anexa una pequeña presentación con estos ejemplos:
https://www.dropbox.com/s/f0r2scmy8qxqfkn/Graficaci%C3%B3nPorComputadora.pptx

Renderizado

    La renderización es el proceso de generar una imagen en 3D a partir de un modelo, usando una aplicación e computadora.

El modelos es una descripción en tres dimensiones de objetos del lenguaje o estructura de datos estrictamente definidos. El modelo debería contener geometría, punto de vista, textura e información de iluminación.

El pre-renderizado es un proceso computacional intensivo que es utilizado generalmente para la creación de películas y su resultado es de muy alta calidad.

Por otra parte, el renderizado en tiempo real es más usado en los juegos en 3D y suele procesarse a través de tarjetas aceleradoras de 3D por ser un proceso sumamente pesado.

http://prezi.com/4bysm2nspcfv/graficas-por-computadora/