TIPOS DE TEXTURAS UTILIZADAS EN GRAFICACIÓN

El mapeo de las texturas es una parte fundamental de la graficación. Consiste en digitalizar un dibujo o una foto (o animación y vídeos) y "pegarla" a un polígono. Una vez conseguido esto, es necesario hacer una corrección de perspectiva. Es un proceso necesario para que los objetos mapeados parezcan realistas y consiste en cálculos matemáticos para asegurar que una textura converge correctamente en las partes de un objeto que están más alejadas del observador, si no se realiza esta tarea, los objetos se ven ondulados.

Otro aspecto importante en el mapeo de texturas es el filtrado, que sirve para que cada pixel tenga una textura diferente a los de su alrededor.

Los métodos más importantes son:


Filtrado Bilineal: Consiste en que la textura que se va a aplicar a un píxel sea una media de las de los pixeles que lo rodean en los ejes X Y.

Filtrado Trilineal: Consiste en un filtrado bilineal, pero ademas se hace una interpolación entre dos texturas empleadas para diferentes distancias. De esta manera, el cambio de una textura a otra es muy suave.

Filtrado Anisotrópico: Este es un filtrado trilineal que se aplica solamente a los objetos que estén visibles y no a toda la escena. De esta manera no se pierde velocidad.

´________________________________________________________________________________

SEMAFORO

CODIGO:

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

int rad=100;
double ang=0,a=0,b=0,c=0,d=0,e=0,f=0,g=0;
void inicializa(void)
{
    glClearColor(1.0,1.0,1.0,1.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-815.0, 1300.0, -615.0, 700.0);
}
void circuloc(int x, int y, int t, int radio)
{
    int angulo=0;
    glPointSize(t);
    glBegin(GL_POINTS);
    glVertex2f(x,y);
    for (angulo=0;angulo<=360; angulo+=1){ glVertex2f(x + sin(angulo) *radio, y + cos(angulo) * radio);}
    glEnd();
}
void circulo(int x, int y, int radio)
{
    int angulo=0;
    glBegin(GL_TRIANGLE_FAN);
    glVertex2f(x,y);
    for (angulo=0;angulo<=360; angulo++)
    {
        glVertex2f(x + sin(angulo) *radio, y + cos(angulo) * radio);
    }
    glEnd();
}
void dibuja(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glBegin(GL_QUADS);
    glColor3f(0.0 , 0.0 , 0.0);
    glVertex2i(170,437);
    glVertex2i(320,437);
    glVertex2i(320,182);
    glVertex2i(170,182);
    glVertex2i(229,183);
    glColor3f(5.0 , 9.0 , 3.0);
    glVertex2i(260,183);
    glVertex2i(260,-193);
    glVertex2i(229,-193);

    glEnd();

    glColor3f(0.0,0.0,0.0);
    circulo(247,226,34);

    glColor3f(0.0,0.0,0.0);
    circulo(247,302,34);

    glColor3f(0.0,0.0,0.0);
    circulo(247,381,34);
    a=a+1; //velocidad
    for(int j=1;j<=10000000;j++){}//pausa
    if(a>1 && a<20)
    {
        glColor3f(1.0,0.0,0.0);
        circulo(247,381,34);
    }
    if(a>20 && a<40)
    {
        glColor3f(0.0,1.0,0.0);
        circulo(247,226,34);
    }
    if(a>40 && a<50)
    {
        glColor3f(1.0,1.0,0.0);
        circulo(247,302,34);
    }
    if(a>55 && a<50)
    {
        glColor3f(1.0,1.0,0.0);
        circulo(247,302,34);
    }
    if(a>60 && a<55)
    {
        glColor3f(1.0,1.0,0.0);
        circulo(247,302,34);
    }
    if(a>60)
    {
        a=0;
    }
    glFlush();
    glutSwapBuffers();
}
int main (int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA| GLUT_DEPTH);    glutInitWindowSize(500,500);
    glutInitWindowPosition(15,10);
    glutCreateWindow("Ventana");
    inicializa();
    glutDisplayFunc(dibuja);
    glutIdleFunc(dibuja);
    glutMainLoop();
    return 0;
}

_________________________________________________________________________________

FOCO Y VENTILADOR

ROTACIÓN DE LETRAS

EL MOVIMIENTO DEL TEXTO SE REALIZA CON LA LETRA "u"


CODIGO:

#include <GL/glut.h>

float  angulo = 0, r, g, b;

void drawText(char *str,float x,float y){
    int i;
    int len = strlen(str);
    glColor3f(r, g, b);
    glRasterPos2f( x, y);
    for(i = 0; i < len; i++){
        glutStrokeCharacter(GLUT_STROKE_ROMAN,str[i]);
    }
}

void drawText1(char *str,float x,float y){
    int i;
    int len = strlen(str);
    glColor3f(r, g, b);
    glRasterPos2f( x, y);
    for(i = 0; i < len; i++){
        glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_10, str[i]);
    }
}

void init(){
    glClearColor(1, 1, 1, 1.0);
    gluOrtho2D(-10, 10, -10, 10);
}


void display(){
    glClear(GL_COLOR_BUFFER_BIT);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glScalef(0.001, 0.001, 1);
        glRotatef(angulo + 10, 0, 0, 0.1);
        drawText1("2016-B", 650, -50);

        glRotatef(angulo, 0, 0, 1);
        drawText("GRAFICACION", 0, 0);

    glutSwapBuffers();
    glFlush();
}

void key(unsigned char c, int x, int y)
{
    switch(c){
        //esc
        case 27:
            exit(0);
            break;
        //up
        case 'u':
            angulo += 5;
            break;
    }
    display();
}

int main( int argc, char ** argv){
    glutInit( &argc, argv);
    glutInitDisplayMode( GLUT_DOUBLE| GLUT_RGB);
    glutInitWindowPosition( 100, 100);
    glutInitWindowSize(700, 700);
    glutCreateWindow( "TEXTOS");

    init();

    glutDisplayFunc(display);
    glutKeyboardFunc(key);

    glutMainLoop();
    return 0;

}

Tarea 5.- Textos Rotados David Gómez Jaramillo

Alumno: David Gómez Jaramillo

Capturas de Pantalla

 

Texto Posición original

Texto Rotado

CÓDIGO:

/**

Programa que hace rotar 2 textos:

Uno sobre su propio eje y en sentido contrario de las manecillas del reloj

y el otro alrededor

Utilizando el botón izquierdo el texto gira a la izquierda

Utilizando el botón derecho el texto gira a la derecha

David Gomez Jaramillo

*/

#include <windows.h>

#include <gl/glut.h>

#include <string.h>

#define WIDTH 700

#define HEIGHT 700

#define TEXTO  "David Gomez"

float rotacion=0;

int x=400, y=400;

void drawText(char *str)//

{

    int i;

    int len=strlen(str);

    glRasterPos2f(x,y);

    glColor3f(1,0,0.1);

    for(i=0;i<len;i++){

        glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,str[i]);

        glutStrokeCharacter(GLUT_STROKE_ROMAN,str[i]);

}

}

void display()

{

      glClear( GL_COLOR_BUFFER_BIT);

      glMatrixMode(GL_MODELVIEW);

      glLoadIdentity();

      glScalef(0.001, 0.001, 0.001);

      glRotatef(rotacion, 0, 0, 1.0);

      drawText(TEXTO);

      glutSwapBuffers();

      glFlush();

}

void mouse(int boton, int grado, int x, int y)

{

    if (boton==GLUT_LEFT_BUTTON && grado == GLUT_DOWN)

    {

     rotacion += 45.0;

    }

    if (boton==GLUT_MIDDLE_BUTTON && grado == GLUT_DOWN)

    {

     rotacion = 0.0;

    }

    if (boton==GLUT_RIGHT_BUTTON && grado == GLUT_DOWN)

    {

     rotacion -= 45.0;

    }

    glutPostRedisplay();

}

void init()

{

    glClearColor( 1.0, 1.0, 1.0, 1.0);

    glColor3f(1.0,0.0,0.0);

}

void ajustarViewPort(int ancho,int alto)

{

     float aspect_ratio;

     aspect_ratio=1;

     if(1>(ancho/alto))

     {

      glViewport(0,0,ancho,ancho/aspect_ratio);

     }

     else{

      glViewport(0,0,alto*aspect_ratio,alto);

     }

}

int main( int argc, char ** argv)

{

    glutInit( &argc, argv);

    glutInitDisplayMode( GLUT_DOUBLE| GLUT_RGB);

    glutInitWindowPosition( 300, 100);

    glutInitWindowSize(WIDTH,HEIGHT);

    glutCreateWindow( "Rotacion de 2 Textos");

    glutReshapeFunc(ajustarViewPort);

    init();

    glutDisplayFunc(display);

    glutMouseFunc(mouse);

    glutMainLoop();

    return 0;

}

Descargar:

Texto_rotador

Letras rotando

Captura de pantalla

Ricardo Daniel González Gómez

Para poder ejecutar la rotación de las palabras, es necesario presionar la tecla

'm' : move

'r' : reset

Codigo
#include </usr/include/GL/glut.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define WIDTH 600
#define HEIGHT 600
#define PI 3.141592653
float r, g, b, ang = 0;
int px, py, alto = 600;
/*
*
*
*
*/
void drawText(char *str,float x,float y){
    int i;
    int len = strlen(str);
    glColor3f(r, g, b);
    glRasterPos2f( x, y);
    for(i = 0; i < len; i++){
        glutStrokeCharacter(GLUT_STROKE_ROMAN,str[i]);
    }
}

void drawText1(char *str,float x,float y){
    int i;
    int len = strlen(str);
    glColor3f(r, g, b);
    glRasterPos2f( x, y);
    for(i = 0; i < len; i++){
        glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, str[i]);
    }
}

void init(){
    glClearColor(1, 1, 1, 1.0);
    gluOrtho2D(-10, 10, -10, 10);
}


void display(){
    glClear(GL_COLOR_BUFFER_BIT);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glScalef(0.001, 0.001, 1);    
        glRotatef(ang + 10, 0, 0, 1);
        drawText1("Ricardo", 350, 0);

        glRotatef(ang, 0, 0, 1);
        drawText("Daniel", 100, 0);
       
    glutSwapBuffers();
    //glutPostRedisplay();
    glFlush();
}

void key(unsigned char c, int x, int y)
{
    switch(c){
        case 27: //ESC
            exit(0);
            break;
        case 'm'://Arriba
            ang += 5;
            break;
        case 'r'://reset
            ang = 0;
            break;
    }
    display();
}

int main( int argc, char ** argv){
    glutInit( &argc, argv);
    glutInitDisplayMode( GLUT_DOUBLE| GLUT_RGB);
    glutInitWindowPosition( 100, 100);
    glutInitWindowSize(WIDTH, HEIGHT);
    glutCreateWindow( "LetraS RotacionaleS.");

    init();

    glutDisplayFunc(display);
    glutKeyboardFunc(key);    

    glutMainLoop();
    return 0;

}

Descargar fuente

Rotación de texto

Cada carácter generado por glutBitmapCharacter se visualiza de modo que el origen (esquina inferior

izquierda) del mapa de bits se encuentre en la posición de visualización actual. Después de cargar el mapa de bits del carácter en el búfer de refresco, se añade a la coordenada de la posición actual de visualización un desplazamiento igual a la anchura del carácter. Como ejemplo, podríamos visualizar una cadena de texto qu contuviera n caracteres de mapa de bits mediante el código siguiente:

glRotatef(rotar, 0, 0, 1.0);

glColor3f(0,0,0);

glRasterPos2f(x,y);

for(i=0;i<len;i++){

        glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,str[i]);

        glutStrokeCharacter(GLUT_STROKE_ROMAN,str[i]);

}

Los caracteres se muestran en el color que haya sido especificado antes de ejecutar la función

glutBitmapCharacter .

Un carácter de contorno se muestra mediante la siguiente llamada a función:

glutStrokeCharacter (font , character) ;

Para esta función, podemos asignar al parámetro font el valor GLUT_STROKE_ROMAN, que muestra una fuente con espaciado proporcional, o el valor GLUT_STROKE_MONO_ROMAN, que muestra una fuente con espaciado constante. Podemos controlar el tamaño y la posición de estos caracteres especificando una serie de operaciones de transformación, (escalar,rotar y trasladar). 

Programa que hace rotar 2 textos , uno sobre su propio eje y el otro alrededor
Utilizando el botón izquierdo el texto gira a la izquierda
Utilizando el botón derecho el texto gira a la derecha

Texto Normal

Tecla Izq. del mouse

Tecla Der. del teclado

/**
Programa que hace rotar 2 textos , uno sobre su propio eje y el otro alrededor
Utilizando el botón izquierdo el texto gira a la izquierda
Utilizando el botón derecho el texto gira a la derecha
Garnica Ayala Hector Daniel
*/
#include <windows.h>
#include <gl/glut.h>
#include <string.h>
#define WIDTH 600
#define HEIGHT 600
#define TEXTO "Hector Daniel"
float rotar=0;
int x=300, y=300;
/********************************/
void drawText(char *str)//
{
    int i;
    int len=strlen(str);
    glColor3f(0,0,0);
    glRasterPos2f(x,y);//va rasterizar el bojeto desde la posicion mencionada
    for(i=0;i<len;i++){
        glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24,str[i]);//transformar el carecter de la cadena a un mapa de bits(viwport) caracter por caracter
        glutStrokeCharacter(GLUT_STROKE_ROMAN,str[i]);// nos permite girar el texto deseado
}
}
/***********************************/
void display()
{
    glClear( GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();//carga la matriz identidad
glScalef(0.001, 0.001, 0.001);
        glRotatef(rotar, 0, 0, 1.0);

        drawText(TEXTO);
    glutSwapBuffers();
    glFlush();
}
/***************************************/
void mouse(int boton, int estado, int x, int y)//no hay coordenadas coordenadasflotantes
{
    if (boton==GLUT_LEFT_BUTTON && estado == GLUT_DOWN) //
    {
    rotar += 20.0;
    }
    if (boton==GLUT_MIDDLE_BUTTON && estado == GLUT_DOWN) //
    {
    rotar = 0.0;
    }
    if (boton==GLUT_RIGHT_BUTTON && estado == GLUT_DOWN) //
    {
    rotar -= 20.0;
    }

    glutPostRedisplay();
}
/******************************************/
void init()
{
    glClearColor( 1.0, 1.0, 1.0, 1.0);
    glColor3f(0.0,0.0,0.0);
}
/*******************************************/
void ajustarViewPort(int ancho,int alto)
{
float aspect_ratio;
aspect_ratio=1;
if(1>(ancho/alto))
{
glViewport(0,0,ancho,ancho/aspect_ratio);
}
else{
glViewport(0,0,alto*aspect_ratio,alto);
}
}
/*****************************************/
int main( int argc, char ** argv)
{
    glutInit( &argc, argv);

    glutInitDisplayMode( GLUT_DOUBLE| GLUT_RGB);
    glutInitWindowPosition( 100, 100);
    glutInitWindowSize(WIDTH,HEIGHT);
    glutCreateWindow( "Rotacion de Texto");
    glutReshapeFunc(ajustarViewPort);
    init();
    glutDisplayFunc(display);
glutMouseFunc(mouse);
    glutMainLoop();
    return 0;
}


Descargar Archivo.txt
Texto.txt

Ajedrez

Capturas de pantalla
En el tablero de ajedrez, la letra G se mueve y tiene los siguientes controles.

Controles

w : arriba

s : abajo

a : izquierda

d : derecha.

Código
#include </usr/include/GL/glut.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define LONG_LADO 10//longitud del lado del cuadrado
#define TRANS_X 2.5//Traslacion en x inicial
#define TRANS_Y 7.5//Traslacion en y inicial
#define TRANS_Z 0.0//Traslacion en y inicial
#define SCALA_G 0.05// escala de la g

float radio=1,a1,a2;
float nx,ny,r,g,b,dx,dy,pi=3.141592653;
float trasX = TRANS_X, trasY = TRANS_Y, trasZ = TRANS_Z;

int puntos=0, ancho=500,alto=500,tam_px=1;
int rot = 0,tx=0,ty=0;

void circulo(float cx,float cy,float radio,float r,float g,float b,float a1,float a2){

    glBegin(GL_POLYGON);
    glColor3f(r,g,b);
    glVertex2f(cx, cy);
    for (float i=a1; i<a2; i+=0.01)
    {
        dx=radio*cos(i)+cx;
        dy=radio*sin(i)+cy;
        glVertex2f(dx, dy);
    }
    glEnd();
}

void tablero(){
    for(int colum = 0; colum < 10; colum++){
        for(int fila = 0; fila < 10; fila++){
            bool edo = true;
            if((colum > 0 && colum < 9) && (fila > 0 && fila < 9)){
                if(colum%2 != 0){//x impar                    
                    if(fila%2 != 0){//x impar
                        glColor3f(0,0,0);//negro
                    }else{//x par
                        glColor3f(1,1,1);//blanco        
                    }                    
                }else{//x par
                    if(fila%2 != 0){//x impar
                        glColor3f(1,1,1);//blanco        
                    }else{//x par
                        glColor3f(0,0,0);//negro
                    }                    
                }
            }else{
                glColor3f(0.282,0.52,0.93);
            }            
            glBegin(GL_QUADS);
                glVertex2i(colum, fila);
                glVertex2i(colum, fila + 1);
                glVertex2i(colum + 1,fila + 1);
                glVertex2i(colum + 1,fila);            
            glEnd();        
        }
    }
}

void dibujarG(){
    int cx=0;int cy=0;
    circulo(cx,cy,5,0.858,0.196,0.211,0.7854,2.7);
    circulo(cx,cy,5,0.956,0.76,0.05,2.65,3.65);
    circulo(cx,cy,5,0.235,0.73,0.33,3.65,5.49);
    circulo(cx,cy,5,0.282,0.52,0.93,5.48,2*3.22);
    circulo(cx,cy,3,1,1,1,0,2*3.1416);
    glColor3f(0.282,0.52,0.93);
    glBegin(GL_TRIANGLE_FAN);
        glVertex2f(0+cx,0.8+cy);glVertex2f(4.98+cx,0.8+cy);
        glVertex2f(4.93+cx,-1+cy);glVertex2f(0+cx,-1+cy);
    glEnd();
}

void display(void){
    glClear(GL_COLOR_BUFFER_BIT);

    glPushMatrix();
        tablero();
    glPopMatrix();

    glPushMatrix();
        glTranslatef(trasX, trasY, trasZ);//x,y,z
        glScalef(SCALA_G, SCALA_G, SCALA_G);
        dibujarG();
    glPopMatrix();

    glFlush();

}

void key(unsigned char c, int x, int y)
{
    switch(c){
        case 27: //ESC
            exit(0);
            break;
        case 'w'://Arriba
            if(trasY < 8){
                trasY += 1;
            }
            break;
        case 's'://Abajo
            if(trasY > 2){
                trasY -= 1;
            }
            break;
        case 'a'://izquierda
            if(trasX > 2){
                trasX -= 1;
            }
            break;
        case 'd'://derecha
            if(trasX < 8){
                trasX += 1;
            }
            break;                          
        case 'r'://reset
            trasX = TRANS_X;
            trasY = TRANS_Y;
            trasZ = TRANS_Z;
            break;
    }
    display();
}

void Init()
{   glClearColor(1.0,1.0,1.0,0);
    gluOrtho2D(0,10,0,10);
    glPointSize(tam_px);
    glEnable(GL_POINT_SMOOTH);

}

int main(int argc, char **argv)
{
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowPosition(100,100);
    glutInitWindowSize(ancho,alto);
    glutCreateWindow("Ajedrez");

    Init();

    glutDisplayFunc(display);
    glutKeyboardFunc(key);

    glutMainLoop();
    return 0;
}


Descargar archivo

Transformaciones Geométricas 

(Héctor Daniel Garnica Ayala)

A continuación  se aplicará la transformación gemétrica de translación a 2 objetos (una mesa y una silla) con las teclas de dirección izquierda y derecha.
Obteniedo como resultado lo siguiente:

Objetos en su estado inicial

Aplicando la Translación

/*
** ELABORADO POR: HECTOR DANIEL GANICA AYALA
** TRANSFORMACIONES GEOMETRICAS
    Se aplica la matriz pop y push para la transformaciones de geometrias haciendo que la mesa y objetos se
    muevan con las teclas de direccion izquierda y derecha
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <windows.h>
#include <GL/gl.h>
#include <GL/glut.h>

float Pi=3.141516;
int band=0;


void Tecla(int tecla, int x, int y)
{
    switch(tecla)
    {
    case(27):
        exit(0);
    case(GLUT_KEY_LEFT):
        band=1;
        break;
    case(GLUT_KEY_RIGHT):
        band=0;
        break;
    default:
        break;
    }
    glutPostRedisplay();//indica que la ventana actual necesita ser redibujada
}


void dibujarMesa()
{
    //MESA
    glColor3f( 0.60,0.40,0.12);
    glBegin(GL_QUADS);
        glVertex2i(-4,0);
        glVertex2i(-4,3);
        glVertex2i(-3,3);
        glVertex2i(-3,0);
    glEnd();

    glColor3f( 0.0,0.0,0.0);
    glBegin(GL_LINE_STRIP);
        glVertex2i(-4,0);
        glVertex2i(-4,3);
        glVertex2i(-3,3);
        glVertex2i(-3,0);
    glEnd();

    glColor3f( 0.60,0.40,0.12);
    glBegin(GL_QUADS);
        glVertex2i(4,0);
        glVertex2i(4,3);
        glVertex2i(3,3);
        glVertex2i(3,0);
    glEnd();

    glColor3f( 0.0,0.0,0.0);
    glBegin(GL_LINE_STRIP);
        glVertex2i(4,0);
        glVertex2i(4,3);
        glVertex2i(3,3);
        glVertex2i(3,0);
    glEnd();

    glColor3f( 0.60,0.40,0.12);
    glBegin(GL_QUADS);
        glVertex2i(-4,3);
        glVertex2i(-4,4);
        glVertex2i(4,4);
        glVertex2i(4,3);
    glEnd();

    glColor3f( 0.0,0.0,0.0);
    glBegin(GL_LINE_STRIP);
        glVertex2i(-4,3);
        glVertex2i(-4,4);
        glVertex2i(4,4);
        glVertex2i(4,3);
    glEnd();

    //FRUTA
    glBegin(GL_POLYGON);
    glColor3f(1.0, 0.8, 0.0);
    for(int i=0; i<100; i++)
    {
        float x = 0.7*cos(i*2*Pi/100);
        float y = 0.7*sin(i*2*Pi/100);
        glVertex2f(x-0.5, y+5.3);

    }
    glEnd();

    glColor3f( 0.0,0.0,0.0);
    glBegin(GL_LINE_STRIP);
    for(int i=0; i<100; i++)
    {
        float x = 0.7*cos(i*2*Pi/100);
        float y = 0.7*sin(i*2*Pi/100);
        glVertex2f(x-0.5, y+5.3);

    }
    glEnd();


    glBegin(GL_POLYGON);
    glColor3f(1.0,0.0,0.0);
    for(int i=0; i<100; i++)
    {
        float x = 0.7*cos(i*2*Pi/100);
        float y = 0.7*sin(i*2*Pi/100);
        glVertex2f(x+0.5, y+5.3);

    }
    glEnd();

    glColor3f( 0.0,0.0,0.0);
    glBegin(GL_LINE_STRIP);
    for(int i=0; i<100; i++)
    {
        float x = 0.7*cos(i*2*Pi/100);
        float y = 0.7*sin(i*2*Pi/100);
        glVertex2f(x+0.5, y+5.3);

    }
    glEnd();

    //FRUTERO
    glColor3f( 0.0,1.0,0.0);
    glBegin(GL_QUADS);
    glVertex2i(-2,4);
    glVertex2i(-2,5);
    glVertex2i(2,5);
    glVertex2i(2,4);
    glEnd();

    glColor3f( 0.0,0.0,0.0);
    glBegin(GL_LINE_STRIP);
    glVertex2i(-2,4);
    glVertex2i(-2,5);
    glVertex2i(2,5);
    glVertex2i(2,4);
    glEnd();



}


void dibujarSilla()
{
    glColor3f( 0.0,0.6,1.0);
    glBegin(GL_QUADS);
        glVertex2i(8,0);
        glVertex2i(8,7);
        glVertex2i(9,7);
        glVertex2i(9,0);
    glEnd();

    glColor3f( 0.0,0.0,0.0);
    glBegin(GL_LINE_STRIP);
        glVertex2i(8,0);
        glVertex2i(8,7);
        glVertex2i(9,7);
        glVertex2i(9,0);
    glEnd();

    glColor3f( 0.0,0.6,1.0);
    glBegin(GL_QUADS);
        glVertex2i(6,0);
        glVertex2i(6,2);
        glVertex2i(7,2);
        glVertex2i(7,0);
    glEnd();

    glColor3f( 0.0,0.0,0.0);
    glBegin(GL_LINE_STRIP);
        glVertex2i(6,0);
        glVertex2i(6,2);
        glVertex2i(7,2);
        glVertex2i(7,0);
    glEnd();

    glColor3f( 0.0,0.6,1.0);
    glBegin(GL_QUADS);
        glVertex2i(6,2);
        glVertex2i(6,3);
        glVertex2i(8,3);
        glVertex2i(8,2);
    glEnd();

    glColor3f( 0.0,0.0,0.0);
    glBegin(GL_LINE_STRIP);
        glVertex2i(6,2);
        glVertex2i(6,3);
        glVertex2i(8,3);
        glVertex2i(8,2);
    glEnd();

}

void dibujarPiso()
{
    glColor3f( 0.0,0.0,0.0);
    glBegin(GL_QUADS);
        glVertex2i(-6,0);
        glVertex2i(-6,-1);
        glVertex2i(10,-1);
        glVertex2i(10,0);
    glEnd();

}

void display()
{

    glClear(GL_COLOR_BUFFER_BIT);
    glMatrixMode(GL_MODELVIEW);

    dibujarPiso();

    if(band==0)
    {
        //GRUPO MESA
        glPushMatrix();
            glColor3f( 0.60,0.40,0.12);
            dibujarMesa();
        glPopMatrix();

        //GRUPO SILLA
        glPushMatrix();
            glColor3f( 0.0,0.6,1.0);
            dibujarSilla();
        glPopMatrix();

    }
    else
    {
        //GRUPO MESA
        glPushMatrix();
            glTranslated(-2, 0, 0);
            glColor3f( 0.60,0.40,0.12);
            dibujarMesa();
        glPopMatrix();

        //GRUPO SILLA
        glPushMatrix();
            glTranslated(0, -4.3, 0);
            glRotated(45,0,0,1);
            glColor3f( 0.0,0.6,1.0);
            dibujarSilla();
        glPopMatrix();
    }
    glFlush();

}


void Init()
{   glClearColor(1.0,1.0,1.0,0);
    gluOrtho2D(-10,10,-10,10);
}
int main(int argc,char** argv)
{

    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize (600, 600);
    glutInitWindowPosition (300, 100);
    glutCreateWindow ("TRANSFORMACIONES");
    Init();
    glutSpecialFunc(Tecla);//FUNCION PARA LEER LAS FLECHAS DE DIRECCION, teclas especiales
    glutDisplayFunc(display);
    glutMainLoop();/** nunca termine también significa que el programa no sale nunca del ciclo de ejecución*/

    return 0;
}

Descargar Archivo.txt
Transformaciones.txt

Tarea 4 - Mesa y Silla movimiento David Gomez Jaramillo

Alumno: David Gómez Jaramillo

Para el movimiento se requiere presionar la tecla "a" y para regresar a su estado original la tecla "d"

Capturas de Pantalla:

Gráfico Original

Traslación y Rotación agregadas

Código:

#include <GL/GLUT.h>

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

float radio=1,a1,a2;

float nx,ny,r,g,b,dx,dy,pi=3.141592653;

int puntos=0, ancho=500,alto=500,tam_px=5;

int rot = 0,tx=0,ty=0;

void circulo(float cx,float cy,float radio,float r,float g,float b,float a1,float a2){

    glBegin(GL_POLYGON);

    glColor3f(r,g,b);

    glVertex2f(cx, cy);

    for (float i=a1; i<a2; i+=0.01)

    {

        dx=radio*cos(i)+cx;

        dy=radio*sin(i)+cy;

        glVertex2f(dx, dy);

    }

    glEnd();

}

void pata(float m1, float m2,float m3,float m4,float m11,float m22,float m33,float m44, float r, float g, float b){

    glBegin(GL_QUADS);

    glColor3f(r,g,b);

    glVertex2f(m1,m11);

    glVertex2f(m2,m22);

    glVertex2f(m3,m33);

    glVertex2f(m4,m44);

    glEnd();

}

void dibujarMesa(){

//------------Pata izq mesa----------------

    pata(-4,-4,-3.5,-3.5,-5,0,0,-5,1,0.7,0);

//-----------tabla mesa --------------------

    pata(-4,2,2,-4,0,0,0.5,0.5,1,0.7,0);

//---------pata der mesa-------------------------

    pata(2,2,1.5,1.5,-5,0,0,-5,1,0.7,0);

}

void dibujafrutero(){

    circulo(-0.5,1.5,0.5,1,0,0,0,7);

    circulo(-1.2,1.5,0.5,1,1,0,0,7);

    pata(-2.5,1,1,-2.5,1.5,1.5,0.5,0.5  ,0,1,0);

}

void dibujarSilla(){

    //----------pata izq silla---------------------------

    pata(3 ,3 ,3.5 ,3.5 ,-5 ,-2 ,-2 ,-5   ,0.3,0,1);

//---------pata der silla----------------------------

    pata(6 ,6 ,6.5 ,6.5 ,-5 ,3 ,3 ,-5   ,0.3,0,1);

//---------tabla silla----------------------------

    pata(3 ,6 ,6.5 ,3.5 ,-2 ,-2 ,-1.5 ,-1.5   ,0.3,0,1);

}

void dibujarPiso(){

    glBegin(GL_LINES);

    glColor3f(0,0,0);

    glVertex2f(-7,-5);

    glVertex2f(7,-5);

    glEnd();

}

void display(void)

{

    glClear(GL_COLOR_BUFFER_BIT);

    dibujarPiso();

    dibujarMesa();

    dibujafrutero();

    dibujarSilla();

    glFlush();

}

void key(unsigned char c, int x, int y)

{

    if (c == 27) {

        exit(0);

    }

    if (c == 'a'){

        glClear(GL_COLOR_BUFFER_BIT);

        dibujarPiso();

        glPushMatrix();

        glTranslatef(-3,0,0);

        dibujarMesa();

        dibujafrutero();

        glPopMatrix();

        glPushMatrix();

        glTranslatef(-3,-3.5,0);

        glRotatef(45, 0, 0, 1);

        dibujarSilla();

        glPopMatrix();

    glFlush();

    }

    if( c == 'd'){

        display();

    }

}

void Init()

{  

    glClearColor(1.0,1.0,1.0,0);

    gluOrtho2D(-10,10,-10,10);

    glPointSize(tam_px);

    glEnable(GL_POINT_SMOOTH);

}

int main(int argc, char **argv)

{

    glutInit(&argc,argv);

    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

    glutInitWindowPosition(100,100);

    glutInitWindowSize(ancho,alto);

    glutCreateWindow("Animacion Mesa");

    Init();

    glutDisplayFunc(display);

    glutKeyboardFunc(key);

    glutMainLoop();

    return 0;

}

Codigo.txt