lunes, 16 de abril de 2007

Previo Practica 7

#include string.h
#include stdio.h
#include GL/glut.h
#include GL/gl.h
#include windows.h
#include math.h
#include stdarg.h
#include malloc.h
/* Windows parameters */
#define WIDTH 600
#define HEIGHT 600
#define TITLE "GLUT Demo: Using Subwindows"
void conv(void);
void onMouse(int button, int state, int x, int y);
void mano(void);
void Humanoide(void);
void Movimiento(void);
void onMouse2(int button, int state, int x, int y);
void onMotion2(int x, int y) ;
void onMotion(int x, int y);
void idle2(void);
int winIdMain;
int winIdSub;
int xo,im,yo,alpha,beta,ven,ven2,inif,aux;
int winIdSub2;
float xf,yf;
char xm[3]="000";
char ym[3]="000";
float r1,r2,r3,r4,r5,r6,rmu1,xmu,ymu,zmu,zp,xp;
float r7,r8,r9,r10,r11,r12,r13,r14,r15;
float x,y,z,brazod, brazoi, pied, piei;
int k=0;
xf=150;
yf=200;
ven=0;
ven2=0;
inif=0;
void init(void)
{
glClear (GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT);
}
void text(GLuint x, GLuint y, GLfloat scale,char *format,char *format2) { //Funcion que escribe texto
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glTranslatef(x, y, 0.0);
glScalef(scale/font_scale, scale/font_scale, scale/font_scale);
//len = (int) strlen(format);
glutStrokeCharacter(GLUT_STROKE_ROMAN, 40);
for(p = buffer; *p; p++)
glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
glutStrokeCharacter(GLUT_STROKE_ROMAN, 44);
va_start(args, format2);
vsprintf(buffer, format2, args);
va_end(args);
//len = (int) strlen(format2);
for(p = buffer; *p; p++)
glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
glutStrokeCharacter(GLUT_STROKE_ROMAN, 41);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
void fractal(void){ //Funcion que calcula el fractal
int ran;
ran = rand()%4;
if(ran==1){
xf=(50+xf)/2;
yf=(200+yf)/2;
}
if(ran==2){
xf=(250+xf)/2;
yf=(200+yf)/2;
}
if(ran==3){
xf=(150+xf)/2;
yf=(50+yf)/2;
}
}
void pinta(void){ //Funcion que pinta fractal
int xe,ze;
float x2,y2;
glColor3f(1.0,1.0,0.0);
glBegin(GL_POINTS);
glVertex3f(50.0f,200.0f,0.0f);
glVertex3f(250.0f,200.0f,0.0f);
glVertex3f(150.0f,50.0f,0.0f);
glEnd();
if(k==0){
glBegin(GL_POINTS);
glVertex3f(xf,yf,0);
glEnd();
k=1;
}
fractal();
glBegin(GL_POINTS);
glVertex3f(xf,yf,0);
glEnd();
}
void Display (void) //Funcion que muestra panatalla principal
{
/* Clean drawing board */
glutSetWindow(winIdMain);
//glLoadIdentity ();
pinta();
glFlush();
}
/* Another display function, this one will be
used to update the graphic subwindow */
void subDisplay (){ //Funcion que muestra contenido de las subventanas
/* Clear subwindow */
if(im==1){
glutSetWindow (winIdSub);
glutSetCursor (GLUT_CURSOR_CYCLE);
glutPositionWindow (20, 20);
glClearColor (0.0, 0.0, 1.0, 0.0);
glClear (GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT);
itoa(xo,xm,10);
itoa(yo,ym,10);
glColor3f(1.0,1.,0.0) ;
glutPassiveMotionFunc(onMotion2);
text(xo,(500-yo),20,xm,ym);
}
if(im==2){
glutSetWindow (winIdSub2);
glutSetCursor (GLUT_CURSOR_SPRAY);
glutPositionWindow (100, 100);
glClearColor (1.0, 0.0,0.0, 0.0);
glClear (GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT);
glColor3f(1.0,1.0,0.0);
glutMouseFunc(onMouse2);
glPushMatrix();
glScalef(0.2,.2,.2);
//glTranslatef(0,0,0.0f);
glPushMatrix();
glScalef(0.4,2.4,2.0);
glTranslatef(-21,2.75f,0.0f);
glRotatef(90,0,0,1);
mano( );
glPopMatrix();
glPushMatrix();
glScalef(0.4,2.4,2.0);
glTranslatef(21,2.75f,0.0f);
glRotatef(-90,0,0,1);
mano();
glPopMatrix();
Humanoide();
glPopMatrix();
glutSwapBuffers ();
}
}
/* Callback function for reshaping the main window */
void Reshape (int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, w, h, 0);
glMatrixMode(GL_MODELVIEW);
}
/* Callback function for reshaping the subwindow */
void subReshape (int w, int h)
{
glViewport (0, 0, w, h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluOrtho2D (0.0F, 1.0F, 0.0F, 1.0F);
}
void idle2(void) //maneja a la subventana
{
Movimiento();
subDisplay();
}
void idle (void) //maneja ventana principal
{
glutSetWindow (winIdMain);
glutPostRedisplay ();
glutSetWindow (winIdSub);
glutPostRedisplay ();
glutSetWindow (winIdSub2);
glutPostRedisplay ();
}
void onMouse(int button, int state, int x, int y) //Funcion de mouse ventana principal
{
if ( (button == GLUT_LEFT_BUTTON) & (state == GLUT_DOWN) ) {
if(ven2==1){
ven2=0;
glutDestroyWindow (winIdSub2);
goto yy;
}
if(ven==0){
winIdSub = glutCreateSubWindow (winIdMain, 500,500, 500 , 500);
glutMouseFunc(onMouse);
im=1;
glutDisplayFunc (subDisplay);
ven=1;
xo=x;
yo=y;
}
else ven=1;
yy: aux=0;
}
if ( (button == GLUT_RIGHT_BUTTON) & (state == GLUT_DOWN) ) {
if(ven==1){
ven=0;
glutDestroyWindow(winIdSub);
goto xx;
}
if(ven2==0){
winIdSub2 = glutCreateSubWindow (winIdMain, 500,500, 500 , 500);
glutMouseFunc(onMouse2);
im=2;
glutDisplayFunc (subDisplay);
glutIdleFunc (idle2);
ven2=1;
xo=x;
yo=y;
}
else ven2=1;
}
xx: aux=1;
}
void onMouse2(int button, int state, int x, int y) //Funcion mouse subventana
{
if ( (button == GLUT_LEFT_BUTTON) & (state == GLUT_DOWN) ) {
if(ven2==1){
ven2=0;
glutSetWindow (winIdMain);
main();
glutDestroyWindow (winIdSub2);
goto yy;
}
if(ven==0){
winIdSub = glutCreateSubWindow (winIdMain, 500,500, 500 , 500);
glutMouseFunc(onMouse);
im=1;
glutDisplayFunc (subDisplay);
ven=1;
xo=x;
yo=y;
}
else ven=1;
yy: aux=0;
}
}
void onMotion(int x, int y) { //Funcion de movimiento del mouse ventana principal
alpha = (alpha + (y - yo));
beta = (beta + (x - xo));
xo = x; yo = y;
glutPostRedisplay();
}
void onMotion2(int x, int y) { //Funcion de movimiento del mouse subventana
alpha = (alpha + (y - yo));
beta = (beta + (x - xo));
xo = x; yo = y;
glutPostRedisplay();
}
void keyboard(unsigned char key, int x, int y) //Evento de teclado
{
switch (key) {
case 27:
exit(0);
break;
}
}
int main (int argc, char **argv)
{
/* Glut initializations */
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGBA GLUT_DEPTH);
glutInitWindowPosition (20,20);
glutInitWindowSize (WIDTH, HEIGHT);
/* Main window creation and setup */
winIdMain = glutCreateWindow (TITLE);
// glutSetWindow (winIdMain);
init ();
glutDisplayFunc (Display);
glutReshapeFunc (Reshape);
glutMouseFunc(onMouse);
glutPassiveMotionFunc(onMotion);
glutKeyboardFunc(keyboard);
glutIdleFunc (idle);
glutMainLoop ();
return 0;
}
void Movimiento(void) //Movimiento aleatorio del humanoide
{
x=rand() %2;
y=rand() %2;
z=rand() %2;
brazod=rand()%80;
brazoi=rand()%80;
pied=rand()%80;
piei=rand()%80;
//ejes de rotación de la muñeca
xmu=rand() %2;
ymu=rand() %2;
zmu=rand() %2;
//àngulo de la muñeca
rmu1=rand()%90;
//angulos de los grados de libertad del dedo medio
r1=rand()%180;
r2=rand()%180;
r3=rand()%180;
//angulos de los grados de libertad del dedo indice
r4=rand()%180;
r5=rand()%180;
r6=rand()%180;
//angulos de los grados de libertad del dedo anular
r7=rand()%180;
r8=rand()%180;
r9=rand()%180;
//angulos de los grados de libertad del dedo meñique
r10=rand()%180;
r11=rand()%180;
r12=rand()%180;
//angulos de los grados de libertad del dedo pulgar
r13=rand()%180;
r14=rand()%180;
r15=rand()%180;
//ejes de rotación del dedo pulgar
zp=1;
xp=0;
}
void Humanoide(void) //Funcion del Humanoide
{
glPushMatrix();
//cabeza
glTranslatef(0.0f,2.5f,0.0f);
glutWireCube (0.5);
//tronco
glScalef(2.5,2.5,2.0);
glTranslatef(0.0f,-0.45f,0.0f);
glutWireCube (0.5);
//piernas
glPushMatrix();
glPushMatrix();
//pierna izquierda
glRotatef(piei,x,y,z);
glTranslatef(-0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPushMatrix();
glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);
glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();
//pies
glPushMatrix();
glTranslatef(.3f,-1.0f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();
//pierna derecha
glRotatef(pied,x,y,z);
glTranslatef(0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPushMatrix();
glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);
glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();
//pies
glTranslatef(-.3f,-1.0f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);

glPopMatrix();
//brazo derecho
glPushMatrix();
glRotatef(brazod,x,y,z);
glTranslatef(0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);
glPushMatrix();
glTranslatef(0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);
glPopMatrix();
glTranslatef(0.7f,0.0f,0.0f);
glScalef(.7,1,1.0);
glutWireCube (0.5);
//brazo izquierdo
glPopMatrix();
glRotatef(brazoi,x,y,z);
glTranslatef(-0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);
glPushMatrix();
glTranslatef(-0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);
glPopMatrix();
glTranslatef(-0.7f,0.0f,0.0f);
glScalef(.7,1,1.0);
glutWireCube (0.5);
glPopMatrix();

}
void mano(void) //Funcion de la mano
{
glRotatef(rmu1,xmu,ymu,zmu);
glPushMatrix();
glTranslatef(-0.1,0.0,0.0f);
glScalef(1.7,2.5,1.0);
glutWireCube (0.5);
glPopMatrix();
//dedo medio
glPushMatrix();
glTranslatef(0.0,0.9,0.0f);
glRotatef(r1,1,0,0);
glScalef(.3,1.2,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.45,0.0f);
glRotatef(r2,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.47,0.0f);
glRotatef(r3,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glPopMatrix();
//dedo indice
glPushMatrix();
glTranslatef(0.2,0.0,0.0f);
glTranslatef(0.0,0.9,0.0f);
glRotatef(r4,1,0,0);
glScalef(.3,1.2,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.45,0.0f);
glRotatef(r5,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.47,0.0f);
glRotatef(r6,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glPopMatrix();
//dedo anular
glPushMatrix();
glTranslatef(-0.2,0.0,0.0f);
glTranslatef(0.0,0.9,0.0f);
glRotatef(r7,1,0,0);
glScalef(.3,1.2,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.45,0.0f);
glRotatef(r8,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.47,0.0f);
glRotatef(r9,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glPopMatrix();
//dedo meñique
glPushMatrix();
glTranslatef(-0.4,0.0,0.0f);
glTranslatef(0.0,0.9,0.0f);
glRotatef(r10,1,0,0);
glScalef(.3,1.2,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.45,0.0f);
glRotatef(r11,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.47,0.0f);
glRotatef(r12,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glPopMatrix();
//dedo pulgar
glPushMatrix();
glTranslatef(0.45,-0.8,0.0f);
glTranslatef(0.0,0.9,0.0f);
glRotatef(r13,xp,0,zp);
glScalef(.3,1.2,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.45,0.0f);
glRotatef(r14,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.47,0.0f);
glRotatef(r15,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glPopMatrix();
}

domingo, 15 de abril de 2007

IMPLEMENTACION DE CURVAS Y SUPERFICIES CON NURBS

Los NURBS (Non-Uniform Rational B-Splines) son entes matemáticos que definen exactamente una curva o superfice a partir de varios puntos de control, no necesariamente pertenecientes a la trayectoria, y unos pesos asociados a los mismos.
Cuanto mayor sea la complejidad de la curva, mayor será el número de puntos de control que deberá especificarse, pero, en todo caso, el número de puntos generados será menor que el necesario utilizando la aproximación tradicional por tramos rectos.

Curvas Nurbs
Son una herramienta importante para trabajar en 3D. Pueden ser una forma simple de modelar una superficie o un avanzado control para la animación, se definen por puntos de control, que controlan la forma de la curva. También consta de otros tipos de punto como los editables, que indica el principio o final de un segmento, y rectas que unen los puntos de control en una curva.

La geometría de la curva se define por: grados, puntos de control, nodos y regla de calculo.

Superficies Nurbs
Tienen los principios de las curvas nurbs, y se aplican igual, sin embargo una diferencia entre curvas y superficies es que las curvas se sometena una sola direccion y la superficie es bidireccional, estas bidireccion tiene un origen llamado normal, que determina la parte frontal o trasera de la misma.

Funciones básicas B-spline
Sea U = {u0, u1, . . . , ul} una secuencia no decreciente de números reales, es decir,
ui ≤ ui+1, i = 0, . . . , l−1. Los ui se denominan nodos y U vector de nodos. La i-esima función básica B-spline de grado p (orden p + 1), denotada por Ni,p(u), está definida recursivamente:
Nótese que las funciones Ni,0(u), i = 0, . . . , m son funciones salto, idénticamente nulas excepto en el intervalo semiabierto [ui, ui+1) (el cual puede tener longitud cero, pues ambos nodos pueden ser iguales). En cambio, para p > 0 la función Ni,p(u) es una combinación lineal de dos funciones básicas de grado (p−1). Por supuesto, la computación de las funciones básicas requiere especificar el vector de nodos U y
el grado p. La derivada de una función básica viene dada por:
Derivando sucesivas veces la expresión (2) obtenemos Nk i,p(u), la derivada k-esima de Ni,p(u), como
2.2 Superficies NURBS
Las superficies mas ampliamente usadas en los procesos de diseño en la industria son las superficies NURBS. Ello se explica por sus grandes ventajas, entre las que figuran sus capacidades para el diseño interactivo y su habilidad para representar de manera precisa formas cerradas, como cónicas y cuadricas. Además, las superficies NURBS incluyen a las superficies B-spline como casos particulares.
De hecho, muchas aplicaciones de CAD/CAM, realidad virtual, animación y visualización usan modelos basados en superficies NURBS y estas superficies están incluidas en muchos de los formatos mas populares en la industria, como IGES. También muchos estándares gráficos mas recientes, tales como PHIGS+ y OpenGL incluyen las superficies NURBS entre sus primitivas gráficas.
Una superficie NURBS9 S(u,v) de grado (p, q) es una función racional bivariada de la forma:
donde {wij}i,j representan los valores escalares de los pesos asociados a los puntos de control {Pij}i=0,...,n;j=0,...,m y con vectores de nodos U y V definidos .
2.3 Derivadas de superficies NURBS
Las derivadas de una superficie NURBS pueden calcularse a partir de las derivadas de A(u, v) y w(u, v) (el numerador y el denominador de la expresión (4) respectivamente) como:
donde dichas derivadas pueden ser fácilmente calculadas a partir de la expresión (3). La expresión (5) indica también que las derivadas de una superficie NURBS se obtienen de forma recursiva y que es posible su computación aplicando un esquema distribuido.

jueves, 12 de abril de 2007

REPORTE PRACTICA 6

//Segun la numeracion esta seria el reporte de la practica 5
//Programa que dibuja lineas, triangulos, y cuadros, se limpia la ventana cada 30 segundos
#include string.h
#include GL/glut.h
#include stdarg.h
#include windows.h
#include stdio.h
#include malloc.h


void pinta(void);
int opcion;
float r,b,g;
float x1,y1,z1;
char string[]="00:00:00";
x0=24;
opcion=1;

void init(void)
{
glClear(GL_COLOR_BUFFER_BIT);
}

void pinta(void){

int xe,ze;
float x2,y2;

if(opcion==1)
{

if(r>=1 b>=1 g>=1){
r=0;
b=0;
g=0;

}
r= r+.1;
b= b+.2;
g= g+.3;
glColor3f(r,b,g);
x1= rand()%500;
y1= rand()%500;
z1= rand()%500;
glBegin(GL_LINES);
glVertex3f(x1,y1,0);
x1= rand()%500;
y1= rand()%500;
z1= rand()%500;
glVertex3f(x1,y1,0);
glEnd();
}

if(opcion==3)
{
if(r>=1 b>=1 g>=1){
r=0;
b=0;
g=0;

}
r= r+.3;
b= b+.1;
g= g+.2;
glColor3f(r,b,g);
y1= rand()%12;
z1= rand()%12;
x2= rand()%500;
y2= rand()%500;

glPushMatrix();
glTranslatef(x2,y2,0);
glScalef(z1,y1,0);

glBegin(GL_LINES);
glVertex3f(10,2,0);
glVertex3f(20,2,0);
glEnd();

glBegin(GL_LINES);
glVertex3f(10,2,0);
glVertex3f(10,12,0);
glEnd();

glBegin(GL_LINES);
glVertex3f(20,2,0);
glVertex3f(20,12,0);
glEnd();

glBegin(GL_LINES);
glVertex3f(10,12,0);
glVertex3f(20,12,0);
glEnd();
glPopMatrix();
}

if(opcion==2)
{
if(r>=1 b>=1 g>=1){
r=0;
b=0;
g=0;

}
r= r+.2;
b= b+.3;
g= g+.1;
glColor3f(r,b,g);
x1= rand()%15;
y1= rand()%15;
x2= rand()%500;
y2= rand()%500;
glPushMatrix();
glTranslatef(x2,y2,0);
glScalef(x1,y1,0);
glBegin(GL_LINES);
glVertex3f(-10,1,0);
glVertex3f(10,1,0);
glEnd();

glBegin(GL_LINES);
glVertex3f(0,20,0);
glVertex3f(-10,1,0);
glEnd();

glBegin(GL_LINES);
glVertex3f(0,20,0);
glVertex3f(10,1,0);
glEnd();

glPopMatrix();
}
}

void display(void)
{
pinta();
glFlush();
}

void reshape(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, w, h, 0);
glMatrixMode(GL_MODELVIEW);
}
//MANEJO DEL RETARDO
void TimerFunction()
{
glutPostRedisplay();
glutTimerFunc(3000, TimerFunction, 1);
}
void TimerFunction2()
{
glutPostRedisplay();
glClear(GL_COLOR_BUFFER_BIT);
glutTimerFunc(30000, TimerFunction2, 2);

}


//ACCIONES DEL MOUSE
void onMouse(int button, int state, int x, int y) {

if ( (button == GLUT_RIGHT_BUTTON) & (state == GLUT_DOWN) ) {
if(opcion==1)
opcion=1;
if(opcion==2)
opcion=1;
if(opcion==3)
opcion=2;
TimerFunction();
}

if ( (button == GLUT_LEFT_BUTTON) & (state == GLUT_DOWN) ) {
if(opcion==3)
opcion=3;
if(opcion==2)
opcion=3;
if(opcion==1)
opcion=2;
TimerFunction();
}
}



int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE GLUT_RGB);
glutInitWindowSize(500, 500);
glutCreateWindow("Reporte Practica 6");
glClearColor(0.0, 0.0, 0.0, 1.0);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(onMouse);
glutTimerFunc(3000, TimerFunction, 1);
glutTimerFunc(30000, TimerFunction2, 2);
glutMouseFunc(onMouse);
glutMainLoop();
return 0;
}

martes, 10 de abril de 2007

Mejoramiento del algoritmo para pendientes de m=1 y m=-1 o mayores

Mejoramiento del algoritmo de linea de Bresenham


void lineaBresenham(int xo,yo,x1,y1){
int dx=x1-xo;
int dy=y1-yo;
int x=xo;
int y=yo;
int do=2*dy-dx;
int dE=2*dy;
int dNE=2*(dy-dx);
int d=do;
int m= (y1-yo)/(x1-xo);
while(x != x1){
if(d <= 0){ //Direccion E
punto(x,y);
x=x+m;
d=d+dE;
}
else{ //Direccion NE
punto(x,y);
x=x+m;
y=y+1;
d=d+dNE;
}
}
}

En este codigo se hace uso de la pendiente para sumarloa la x para calcular la detla d, y asi poder manejar pendientesde m=1 y m=-1 o mayores en valor.

Previo Practica 5 Bitmap Mejorado version2

La version pasada no hace grande y chico el nombre esta si.


#include GL/glut.h
#include stdlib.h
#include stdio.h
#include windows.h
#include math.h

void text(GLuint x, GLuint y, char* format); //Pinta el nombre
void onMouse(int button, int state, int x, int y); //Eventos boton del mouse
void onMotion(int x, int y); //Evento de movimiento del mouse
GLint incrementa = 0;
float alpha, beta;
int xo, yo;
void init(void)
{
glClearColor (0.0, 0.0, 1.0, 0.0);
glShadeModel (GL_FLAT);
}
void text(GLuint x, GLuint y, char* format) {
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glTranslatef(x, y, 0.0);
glRasterPos3f (90,180,0);
if(incrementa == 0)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_10, *p);
if(incrementa == 1)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_HELVETICA_10, *p);
if(incrementa == 2)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_8_BY_13, *p);
if(incrementa == 3)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, *p);
if(incrementa == 4)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, *p);
if(incrementa == 5)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, *p);
if(incrementa == 6)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, *p);
if(incrementa >=7)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, *p);
if(incrementa <= -1)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_10, *p);
//glRasterPos3f(500,0,0);
//glReadPixels(85,165,150,50,GL_RGB,GL_BITMAP,pix);
//glDrawPixels(150,50,GL_RGB,GL_BITMAP,pix);
//glColor3f(1.0,1.0,0.0);
//glBitmap (80,70,80, 180,10, 10,*p);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
void onMouse(int button, int state, int x, int y)
{
if ( (button == GLUT_LEFT_BUTTON) & (state == GLUT_DOWN) ) {
incrementa++;
xo=x;
yo=y;
}
if ( (button == GLUT_RIGHT_BUTTON) & (state == GLUT_DOWN) ) {
incrementa--;
xo=x;
yo=y;
}
}
void onMotion(int x, int y) {
alpha = (alpha + (y - yo));
beta = (beta + (x - xo));
xo = x; yo = y;
glutPostRedisplay();
}
void display(void)
{
GLint command = 1;
glClear (GL_COLOR_BUFFER_BIT);
//glColor3f (1.0, 1.0, 1.0);
glLoadIdentity (); /* clear the matrix */
/* viewing transformation */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
if (command) {
glColor3f(1.0,1.,0.0) ;
text(250,200, "%s", "aide");
}
glFlush ();
}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}
/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (0,0);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutMouseFunc(onMouse);
glutMotionFunc(onMotion);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

lunes, 9 de abril de 2007

Previo Practica 5 glutBitmapCharacter Creacion del Nombre

#include GL/glut.h
#include stdlib.h
#include stdio.h
#include windows.h
#include math.h

void text(GLuint x, GLuint y, GLfloat scale, char* format);

GLint CrearFuente ();
void EscribirCadena (GLint fuente, char *cadena);
void aux(void);

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

void text(GLuint x, GLuint y, GLfloat scale, char* format) {
GLvoid *pix;
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
pix=NULL;
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);

glRasterPos3f (90,180,0);
for(p = buffer; *p; p++){
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, *p);
//

}

glRasterPos3f(500,0,0);
glReadPixels(85,165,150,50,GL_RGB,GL_BITMAP,pix);
glDrawPixels(150,50,GL_RGB,GL_BITMAP,pix);
//glColor3f(1.0,1.0,0.0);
//glBitmap (80,70,80, 180,10, 10,*p);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
void aux(void){
GLvoid *pix;
pix=NULL;
glReadPixels(0,0,500,500,GL_RGB,GL_BITMAP,pix);
glRasterPos3f(0,250,0);
glColor3f(1.0,0.0,0.0);
glDrawPixels(500,500,GL_RGB,GL_BITMAP,pix);
}

void display(void)
{
GLint command = 1;
glClear (GL_COLOR_BUFFER_BIT);
//glColor3f (1.0, 1.0, 1.0);
glLoadIdentity (); /* clear the matrix */
/* viewing transformation */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);


if (command) {
glColor3f(1.0,1.,0.0) ;
text(100,100, 80, "%s", "AIDE");
}
//aux();
glFlush ();
}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (0,0);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();

return 0;
}

Previo Practica 5 glutStrokeCharacter Creacion del Nombre

#include GL/glut.h
#include stdlib.h
#include stdio.h
#include windows.h
#include math.h

void text(GLuint x, GLuint y, GLfloat scale, char* format);
void onMouse(int button, int state, int x, int y);
void onMotion(int x, int y);
GLint incrementa = 10;
float alpha, beta;
int xo, yo;

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

void text(GLuint x, GLuint y, GLfloat scale, char* format) {
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glTranslatef(x, y, 0.0);
glScalef(scale/font_scale, scale/font_scale, scale/font_scale);
for(p = buffer; *p; p++)
glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
void onMouse(int button, int state, int x, int y)
{
if ( (button == GLUT_LEFT_BUTTON) & (state == GLUT_DOWN) ) {
incrementa = incrementa + 5;
xo=x;
yo=y;
}
if ( (button == GLUT_RIGHT_BUTTON) & (state == GLUT_DOWN) ) {
incrementa = incrementa - 5;
xo=x;
yo=y;
}
}

void onMotion(int x, int y) {
alpha = (alpha + (y - yo));
beta = (beta + (x - xo));
xo = x; yo = y;
glutPostRedisplay();
}

void display(void)
{
GLint command = 1;
glClear (GL_COLOR_BUFFER_BIT);
//glColor3f (1.0, 1.0, 1.0);
glLoadIdentity (); /* clear the matrix */
/* viewing transformation */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

if (command) {
glColor3f(1.0,1.,0.0) ;
text(250,200, incrementa, "%s", "aide");
}

glFlush ();
}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (0,0);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutMouseFunc(onMouse);
glutMotionFunc(onMotion);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();

return 0;
}

PREVIO PRACTICA 5 RELOJ USO DE FUNCION TIMER

#include GL/glut.h
#include stdlib.h
#include stdio.h
#include windows.h
#include math.h

void text(GLuint x, GLuint y, GLfloat scale, char* format);
void onMouse(int button, int state, int x, int y);
void onMotion(int x, int y);
void auxiliar(void);
void TimerFunction(int value);

int h1,h2,m1,m2,s1,s2;
GLint incrementa = 20;
float alpha, beta;
int xo, yo,sigue;
s1=0;
m1=0;
h1=0;
s2=0;
m2=0;
h2=0;
sigue=0;
void init(void)
{
glClearColor (0.0, 0.0, 1.0, 0.0);
glShadeModel (GL_FLAT);
}

void text(GLuint x, GLuint y, GLfloat scale, char *format) {
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glTranslatef(x, y, 0.0);
glScalef(scale/font_scale, scale/font_scale, scale/font_scale);
for(p = buffer; *p; p++)
glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
glutStrokeCharacter(GLUT_STROKE_ROMAN, h2+48);
glutStrokeCharacter(GLUT_STROKE_ROMAN, h1+48);
glutStrokeCharacter(GLUT_STROKE_ROMAN, 58);
glutStrokeCharacter(GLUT_STROKE_ROMAN, m2+48);
glutStrokeCharacter(GLUT_STROKE_ROMAN, m1+48);
glutStrokeCharacter(GLUT_STROKE_ROMAN, 58);
glutStrokeCharacter(GLUT_STROKE_ROMAN, s2+48);
glutStrokeCharacter(GLUT_STROKE_ROMAN, s1+48);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
void TimerFunction(int value)
{
s1++;
if(s1==10){
s2++;
s1=0;
if(s2==6){
s2=0;
m1++;
if(m1==10){
m1=0;
m2++;
if(m2==6){
m2=0;
h1++;
if(h1==10){
h1=0;
if(h2==2){
m1=m2=s1=s2=h1=h2=0;
}
}
}
}
}
}
glutPostRedisplay();
if(sigue==1)
glutTimerFunc(1000,TimerFunction,1);
}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}
void onMouse(int button, int state, int x, int y)
{
if ( (button == GLUT_LEFT_BUTTON) & (state == GLUT_DOWN)) {
sigue=1;
auxiliar();
xo=x;
yo=y;
}

if ( (button == GLUT_RIGHT_BUTTON) & (state == GLUT_DOWN) ) {
sigue=0;

xo=x;
yo=y;
}

}

void onMotion(int x, int y) {
alpha = (alpha + (y - yo));
beta = (beta + (x - xo));
xo = x; yo = y;
glutPostRedisplay();
}

void display(void)
{
GLint command = 1;
glClear (GL_COLOR_BUFFER_BITGL_DEPTH_BUFFER_BIT);

glLoadIdentity (); /* clear the matrix */
/* viewing transformation */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

if (command) {
glColor3f(1.0,1.,0.0) ;
text(250,200, incrementa, "%s","Reloj ");
}

glutSwapBuffers();
}


int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (0,0);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutMouseFunc(onMouse);
glutMotionFunc(onMotion);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

void auxiliar(void){
if(sigue==1)
glutTimerFunc(1000,TimerFunction,1);

}

Previo Practica 5 parte 1


API_GLUT

int glutCreateWindow (char *nombre)
Crea la ventana, y el parámetro es el nombre de la misma. nombre: cadena de caracteres con el nombre de la ventana. Devuelve un entero que es el identificador único de la ventana. Esta función crea una ventana principal. Cuando se crea una ventana, la ventana activa pasa a ser esta nueva ventana. Toda ventana lleva implícito un contexto de visualización de OpenGL. Este contexto es el que permite que la ventana creada con GLUT (o en su caso, con cualquier entorno de ventanas) se ponga en contacto con OpenGL. Las ventanas creadas con esta función no son visualizadas todavía. La visualización la llevará a cabo una función de respuesta al evento de redibujado de la ventana.

void glutInit (int *argc, char **argv)
argc: puntero al parámetro argc de la función main del programa.
argv: parámetro argv de la función main.
glutInit inicializa la librería GLUT, pudiéndosele pasar algún parámetro por línea de comandos a través de argc y argv. Esta rutina debe ser llamada una única vez al principio del programa. Ninguna otra función que no sea de inicialización puede llamarse antes. Si utilizamos alguna
función de inicialización (con el prefijo glutInit-) delante de ésta función, estamos fijando el estado por defecto de la aplicación al inicializarse.

void glutInitWindowSize (int ancho, int alto)
ancho: anchura de la ventana en pixels
alto: altura de la ventana en pixels
Esta rutina sirve para indicar el tamaño inicial de las ventanas que se creen.

void glutInitWindowPosition (int x, int y)
x: posición en x de la ventana en pixels
y: posición en y de la ventana en pixels
Con esta función fijamos la posición inicial de las ventanas que se creen. Inicializar la posición de la ventana en el escritorio.

void glutInitDisplayMode (unsigned int modo)
Inicializa el modo de visualización.
modo: modo de display. Es una composición mediante conectores “” de algunos de
los valores siguientes:
GLUT_RGBA: Selecciona una ventana en modo RGBA. Es el valor por defecto si no se indican ni GLUT_RGBA ni GLUT_INDEX.
GLUT_RGB: Lo mismo que GLUT_RGBA.
GLUT_INDEX: Seleciona una ventana en modo de índice de colores. Se impone sobre GLUT_RGBA.
GLUT_SINGLE: Selecciona una ventana en modo buffer simple. Es el valor por defecto.
GLUT_DOUBLE: Selecciona una ventana en modo buffer doble. Se impone sobre GLUT_SINGLE.
GLUT_ACCUM: Selecciona una ventana con un buffer acumulativo.
GLUT_ALPHA: Selecciona una ventana con una componente alfa del buffer de color.
GLUT_DEPTH: Selecciona una ventana con un buffer de profundidad.
GLUT_STENCIL: Selecciona una ventana con un buffer de estarcido.
GLUT_MULTISAMPLE: Selecciona una ventana con soporte multimuestra.
GLUT_STEREO : Selecciona una ventana estéreo.
GLUT_LUMINANCE: Selecciona una ventana con un modelo de color en tonos de gris.
Esta función fija el modo de display inicial con que se crearán las ventanas. Los dos valores que suelen darse en la mayoría de las aplicaciones son GLUT_RGBA, para fijar un modelo de color RGB con componente alfa, y GLUT_DOUBLE para seleccionar una ventana con doble buffer.

glutDisplayFunc(void (*func)(void));
La función func() se llamará cada vez que haya que redibujar la ventana.
GLUT no proporciona una función de respuesta por defecto para el redibujado, por lo que es obligatorio escribir una función de este tipo para cada ventana creada. Si se crea una ventana y no se registra la función de respuesta al redibujado, se produce un error.

glutInitPosition(int x, int y);
Posición x e y de la esquina superior izquierda de la nueva ventana, con respecto al escritorio en el que se trabaje.

glutKeyboardFunc(void (*func)(unsigned char key, int x, int y));
func: función de respuesta al evento.
Se utiliza para registrar la función que responde a eventos del teclado sobre la ventana activa. La función de respuesta debe tener como parámetros la tecla que se ha pulsado (su carácter ASCII) y la posición (x,y) del puntero del ratón en ese momento, relativa a la ventana. No es posible detectar las teclas de modificadores directamente (CTRL, ALT, ...). Debemos utilizar para ello la función glutGetModifiers. Si no se registra ninguna función, los eventos de teclado son ignorados.

glutMainLoop();
Esta rutina debe llamarse una vez en el programa. Puesto que implementa un bucle infinito (realmente el bucle termina cuando se produce un evento de cerrar aplicación), la función no termina nunca. Por ello es necesario registrar previamente las funciones callback y que, además, la llamada a esta función sea la última de main.

glutMouseFunc(void (*func)(int button, int state, int x, int y));
Registra para la ventana activa la función de respuesta a eventos del ratón. Los eventos de ratón se producen tanto cuando se pulsa como cuando se suelta un botón del ratón. Los parámetros de la función de respuesta deben ser el botón (GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON o GLUT_RIGHT_BUTTON), el estado del botón (GLUT_UP o GLUT_DOWN) y la posición (x,y) del puntero relativa a la ventana.
Cuando existe un menú asociado a un botón del ratón, el evento de pulsar ese botón es ignorado, prevaleciendo el menú sobre otras funcionalidades. Como en el caso del teclado, es posible detectar el uso de modificadores con la función glutGetModifiers. Si no registra una función de respuesta a eventos del ratón, éstos son ignorados.

glutReshapeFunc(void (*func)(int ancho, int alto));
Registra la función de respuesta al evento de redimensionamiento de la ventana activa. La función de respuesta debe tener como parámetros la anchura y la altura de la ventana tras el redimensionamiento. GLUT dispone, en este caso, de una función de respuesta por defecto, que se utiliza cuando no se registra ninguna función para este evento. El redimensionamiento de la ventana principal no genera ningún evento de redimensionamiento de sus subventanas, por lo que es necesario realizarlo explícitamente.

glutPostRedisplay();
Solicita el redibujado de la ventana actual.

glutSolidCone(Gldouble base, Gldouble height, Glint slices, Glint stacks);
Dibuja un cono sólido, con un radio de longitud base, una altura height, numero de divisiones alrededor del eje z (slices) y numero de divisiones a lo largo del eje z.

glutWireCone(Gldouble base, Gldouble height, Glint slices, Glint stacks);
Dibuja un cono con líneas, con un radio de longitud base, una altura height, numero de divisiones alrededor del eje z (slices) y numero de divisiones a lo largo del eje z.

glutSolidCube(Gldouble size);
Dibuja un cubo sólido, con size de longitud por lado.

glutWireCube(Gldouble size);
Dibuja un cubo con líneas, con size de longitud por lado.

glutSolidDodecahedron();
Dibuja un dodecaedro sólido.

glutWireDodecahedron();
Dibuja un dodecaedro con líneas.

glutSolidIcosahedron();
Dibuja un icosaedro sólido.

glutWireIcosahedron();
Dibuja un icosaedro con líneas.

glutSolidOctahedron();
Dibuja un octaedro sólido.

glutWireOctahedron();
Dibuja un octaedro con líneas.

glutSolidSphere(Gldouble radius, Glint slices, Glint stacks);
Dibuja una esfera sólido, los parámetros son el radio, numero de divisiones alrededor del eje z (slices) y numero de divisiones a lo largo del eje z.

glutWireSphere(Gldouble radius, Glint slices, Glint stacks);
Dibuja una esfera con líneas, los parámetros son el radio, numero de divisiones alrededor del eje z (slices) y numero de divisiones a lo largo del eje z.

glutSolidTetrahedron();
Dibuja un tetraedro sólido.

glutWireTetrahedron();
Dibuja un tetraedro con líneas.

glutSolidTorus(Gldouble innerRadius, Gldouble outerRadius, Glint nSides, Glint nRings);
Dibuja un toroide sólido, los parámetros son el radio interior, radio exterior, numero de divisiones radiales para cada sección nSides, y numero de secciones radiales nRings.

glutWireTorus(Gldouble innerRadius, Gldouble outerRadius, Glint nSides, Glint nRings);
Dibuja un toroide con líneas, los parámetros son el radio interior, radio exterior, numero de divisiones radiales para cada sección nSides, y numero de secciones radiales nRings.

glutSolidTeapot(Gldouble size);
Dibuja una tetera sólida, con un radio size.

glutWireTeapot(Gldouble size);
Dibuja una tetera con líneas con un radio size.

glutSpecialFunc(void (*func)(int key, int x, int y));
Registra para la ventana activa el evento de pulsar una tecla especial. El parámetro tecla puede ser GLUT_KEY_Fn para teclas de función (n=1, 2, ..., 12), GLUT_KEY_RIGHT, GLUT_KEY_LEFT, GLUT_KEY_UP, GLUT_KEY_DOWN, GLUT_KEY_PAGE_UP, GLUT_KEY_PAGE_DOWN, GLUT_KEY_HOME, GLUT_KEY_END , GLUT_KEY_INSERT, GLUT KEY F1 , GLUT KEY F2,GLUT KEY F3,GLUT KEY F4,GLUT KEY F5,GLUT KEY F6, GLUT KEY F7,GLUT KEY F8,GLUT KEY F9,GLUT KEY F10, GLUT KEY F11, GLUT KEY F12.

void glutSwapBuffers (void)
Intercambia los buffers de la ventana actual. Se utiliza en el modo de doble buffer. Esta importante característica de OpenGL (y de GLUT por extensión) hace que se reduzcan al mínimo los parpadeos durante el redibujado, especialmente si hay animaciones. La ventana tiene dos buffers: uno de ellos visible y el otro invisible. El dibujo se realiza en el buffer oculto y, al intercambiarlos, se dibuja todo de una vez, eliminando así el parpadeo. Este tema lo trataremos con detalle cuando veamos OpenGL.

glutTimerFunc(unsigned int msecs, (*func)(int value), int value);
msecs: Número de milisegundos del temporizador
func: Función de respuesta al evento
value: Valor que debe utilizarse para llamar a la función de respuesta Registra tanto un temporizador como la función de respuesta al mismo.
Debemos indicar el tiempo en milisegundos, un valor de identificación del temporizador y la función que responde al mismo, cuyo único parámetro debe ser el identificador del temporizador.


int glutGet (GLenum estado)
estado: variable concreta de estado para la que deseamos obtener información.
Devuelve un entero indicando el valor de la variable referida.
Esta función devuelve el valor de una variable de estado. El parámetro estado hace referencia a la variable de la que deseamos conocer su valor. Este parámetro es un valor de una enumeración, entre cuyos valores encontramos GLUT_WINDOW_X, GLUT_WINDOW_Y, para obtener la posición de la ventana activa, GLUT_WINDOW_WIDTH, GLUT_WINDOW_HIGHT, para obtener el tamaño de la ventana activa, GLUT_WINDOW_PARENT, para obtener el identificador de la ventana padre de la activa, etc.
GLUT WINDOW X X localizacion en pixeles respecto al origen,GLUT WINDOW Y Y localizacion relativa,GLUT WINDOW WIDTH ancho,GLUT WINDOW HEIGHT alto,GLUT WINDOW BUFFER SIZE numero de bits de la ventana para color puede ser tambien GLUT WINDOW RED SIZE para tono rojo, GLUT WINDOW GREEN SIZE tono verde,
GLUT WINDOW BLUE SIZE tono azul, y GLUT WINDOW ALPHA SIZE alfa.
GLUT WINDOW STENCIL SIZE numero de bits en el stencil buffer.
GLUT WINDOW DEPTH SIZE Number of bits in the current window’s depth buffer.
GLUT WINDOW ACCUM RED SIZE numero de bits acumulados en el buffer que son rojos,GLUT WINDOW ACCUM GREEN SIZE verdes, GLUT WINDOW ACCUM BLUE SIZE azules y GLUT WINDOW ACCUM ALPHA SIZE alfa.GLUT WINDOW DOUBLEBUFFER si esta activado el doble buffer, GLUT WINDOW RGBA si esta en modo RGBA, GLUT WINDOW PARENT numero de ventanas padres, GLUT WINDOW NUM CHILDREN numero de ventanas hijas, GLUT WINDOW COLORMAP SIZE tamaño del indice de color, GLUT WINDOW NUM SAMPLES numero de ejemplos, GLUT WINDOW STEREO si maneja stereo, GLUT WINDOW CURSOR para el cursor,GLUT SCREEN WIDTH ancho de pantalla en pixeles,GLUT SCREEN HEIGHT alto en pixeles en pantalla, GLUT SCREEN WIDTH MM ancho de pantalla en milimetros,GLUT SCREEN HEIGHT MM alto de pantalla en milimetros, GLUT MENU NUM ITEMS numero de items en el menu, GLUT DISPLAY MODE POSSIBLE modo de pantalla soportado, GLUT INIT DISPLAY MODE pantalla incial con mascara, GLUT INIT WINDOW X valor inicial de la x, GLUT INIT WINDOW Y valor inicial de la posicion y,GLUT INIT WINDOW WIDTH ancho inicial de la pantalla, GLUT INIT WINDOW HEIGHT alto inicial de la pantalla, GLUT ELAPSED TIME numero en milisegundos desde que glutIni llamo a glutGet.

int glutDeviceGet (GLenum info)
info: dispositivo sobre el que obtener información
Devuelve información sobre el dispositivo indicado
Obtener información sobre los dispositivos del sistema. El parámetro info indica el dispositivo: GLUT_HAS_KEYBOARD, GLUT_HAS_MOUSE, GLUT_NUM_MOUSE_BUTTONS, etc. En los dos primeros casos, la función devuelve 0 si no existe el dispositivo y otro valor si existe. En el tercer caso, devuelve el número de botones del ratón. Existen valores de la enumeración para otros dispositivos.

int glutGetModifiers (void)
Devuelve un valor que indica el modificador que se ha pulsado.
Devuelve la tecla modificadora que ha sido pulsada: GLUT_ACTIVE_SHIFT, GLUT_ACTIVE_CTRL o GLUT_ACTIVE_ALT. La librería GLUT permite realizar otras muchas acciones, referentes al manejo del color, a la visualización de texto, al control de las capas y al diseño de algunas primitivas geométricas.

void glutIdleFunc (void (*funcion) (void))
funcion: función de respuesta al evento
Registra la función de respuesta al evento idle. Este evento se produce cada vez que el sistema no tiene ningún otro evento que atender. En OpenGL se suele utilizar para hacer animaciones. La función que da respuesta al evento debe ser lo más pequeña posible para evitar mermas en la capacidad de interacción de la aplicación.

void glutMenuStatusFunc (void (*funcion) (int estado, int x, int y))
funcion: función de respuesta al evento
Registra la función que responde al evento que se produce cuando se despliega o se pliega un menú. El parámetro estado puede valer GLUT_MENU_IN_USE cuando se despliega un menú, o GLUT_MENU_NOT_IN_USE cuando se pliega. Los valores (x,y) son la posición del puntero del ratón en cada caso.

void glutMotionFunc (void (*funcion) (int x, int y))
La función func(x, y) se llamará cuando el mouse se mueva mientras está pulsado uno de sus botones.
Registra para la ventana activa la función de respuesta a movimientos del ratón cuando se mantiene pulsado algún botón del mismo. Los parámetros (x,y) indican la posición del puntero en coordenadas relativas a la ventana.

void glutPassiveMotionFunc (void (*funcion) (int x, int y))
Registra para la ventana activa la función de respuesta a movimientos del ratón cuando no se mantiene pulsado ningún botón del mismo. Los parámetros (x,y) indican la posición del puntero en coordenadas relativas a la ventana.

void glutVisibilityFunc (void (*funcion) (int estado)):
Registra para la ventana activa la función de respuesta al evento de cambios en la visibilidad de la ventana. El parámetro estado puede ser GLUT_NOT_VISIBLE o GLUT_VISIBLE.

void glutEntryFunc (void (*funcion) (int estado)):
Registra para la ventana activa la función de respuesta al evento de entrada y salida del ratón en el área de la ventana. El parámetro estado puede ser GLUT_LEFT o GLUT_ENTERED.

int glutCreateSubWindow (int idVentanaPadre, int x, int y, int ancho, int alto)
idVentanaPadre: identificador de la ventana padre de la subventana
x, y: posición (x,y) en pixels de la subventana, relativa a la ventana padre ancho, alto: anchura y altura de la subventana en pixels. Devuelve un identificador único para la subventana
Esta rutina crea una subventana, hija de la ventana identificada por idVentanaPadre. La ventana activa de la aplicación pasa a ser la nueva subventana. Como en el caso de las ventanas principales, las subventanas llevan asociado un contexto de visualización, y su modo de display viene dado por las especificaciones iniciales (no así su tamaño y su posición, que en este caso son dados explícitamente).

void glutSetWindow (int idVentana)
idVentana: identificador de la ventana
Fija la ventana identificada por idVentana como ventana activa.

int glutGetWindow (void)
Devuelve el identificador de la ventana activa

void glutDestroyWindow (int idVentana)
idVentana: identificador de la ventana. Destruye la ventana identificada por idVentana.

void glutPositionWindow (int x, int y)
x, y: posición (x,y) en pixels de la ventana
Solicita el cambio de la posición de la ventana actual en la pantalla. Si la ventana actual es principal, (x,y) se toma con referencia al origen de la pantalla. Si es una subventana, la distancia se toma con referencia al origen de la ventana padre.

void glutReshapeWindow (int ancho, int alto)
ancho: anchura de la ventana en pixels
alto: altura de la ventana el pixels
Solicita el cambio del tamaño de la ventana actual, dándole al ancho y el alto especificados.
Otras funciones referentes a las ventanas se muestran a continuación junto con una breve descripción.

void glutFullScreen (void):
Solicita que la ventana actual sea maximizada. Sólo funciona para ventanas principales.

void glutPopWindow (void):
Adelanta la ventana actual una posición en la pila de ventanas.

void glutPushWindow (void):
Retrasa la ventana actual una posición en la pila de ventanas.

void glutShowWindow (void):
Muestra la ventana actual.

void glutHideWindow (void):
Oculta la ventana actual.

void glutIconifyWindow (void):
Solicita la minimización de la ventana actual y su conversión en icono.

void glutSetWindowTitle (char *nombre):
Cambia el nombre de la ventana actual.

void glutSetIconTitle (char *nombre):
Da nombre a la ventana actual cuando está minimizada.

void glutSetCursor (int cursor):
Cambia el puntero del ratón cuando sobrevuela la ventana actual. El parámetro es un valor de una enumeración.
GLUT CURSOR RIGHT ARROW, GLUT CURSOR LEFT ARROW,GLUT CURSOR INFO,GLUT CURSOR DESTROY,GLUT CURSOR HELP,GLUT CURSOR CYCLE,GLUT CURSOR SPRAY,
GLUT CURSOR WAIT,GLUT CURSOR TEXT, GLUT CURSOR CROSSHAIR, GLUT CURSOR UP DOWN, GLUT CURSOR LEFT RIGHT, GLUT CURSOR TOP SIDE, GLUT CURSOR BOTTOM SIDE, GLUT CURSOR LEFT SIDE, GLUT CURSOR RIGHT SIDE, GLUT CURSOR TOP LEFT CORNER, GLUT CURSOR TOP RIGHT CORNER, GLUT CURSOR BOTTOM RIGHT CORNER, GLUT CURSOR BOTTOM LEFT CORNER, GLUT CURSOR FULL CROSSHAIR, GLUT CURSOR CROSSHAIR).,GLUT CURSOR NONE,GLUT CURSOR INHERIT.

int glutCreateMenu (void (*funcion) (int valor))
Esta función crea un menú (todavía sin opciones), y le asigna la función func(value). Esta función se llamará cada vez que una de las opciones del menú sea seleccionada por el usuario, y recibirá en value el código identificativo de la opción seleccionada. De esta manera, podremos definir que hace cada opción de menú. Devuelve un identificador de menú, que nos
servirá cuando tengamos que referirnos a él.
funcion: Función callback a la que se llama cuando se selecciona un ítem del menú.
El valor que se le pasa a la función identifica al ítem del menú.
Devuelve un identificador único para el menú.
Esta función crea un menú flotante asociado a la ventana actual y devuelve un identificador único para el mismo. Este menú pasa a ser el menú activo.

void glutSetMenu (int idMenu)
Esta función hace que el menú identificado como idmenu sea el menú actual.
Por defecto, el menú actual es el último que se ha creado.
idMenu: identificador del menú.
Esta función pone el menú identificado por idMenu como menú activo.

int glutGetMenu (void)
Devuelve un identificador de menú. Devuelve el identificador del menú activo.

void glutDestroyMenu (int idMenu)
idMenu: identificador del menú. Destruye el menú identificado por idMenu.

void glutAddMenuEntry (char *nombre, int valor)
Añade una opción de menú al menú actual. Esta opción se llamará nombre y
se identificará por el número valor.
nombre: cadena de caracteres que aparece en la opción del menú valor: identificador para el ítem del menú. Este valor es el que se pasa a la función de respuesta al menú.
Añade una entrada al final del menú activo, y la cadena que se visualiza es el nombre. Cuando el usuario selecciona esa opción, se llama a la función de respuesta con el valor como parámetro.

void glutAddSubMenu (char *nombre, int idMenu)
Añade una opción de menú que abrirá un submenú.
nombre: cadena de caracteres que aparece en la opción del menú principal.
idMenu: identificador del submenú asociado al ítem.
Crea un ítem del menú y le asocia un submenú que se despliega al ser seleccionada la entrada del menú principal. El submenú debe haber sido creado previamente como cualquier otro menú.


void glutChangeToSubMenu (int entrada, char *nombre, int valor):
Cambia un submenú por otro.

void glutRemoveMenuItem (int entrada):
Elimina una entrada del menú.

void glutDetachMenu (int boton):
Elimina la asociación entre el menú activo y el botón del ratón.

void glutAttachMenu (int boton)
boton: botón del ratón al que asociamos el menú.
Asocia el menú activo a un botón del ratón en la ventana activa, de manera que el menú se despliega cuando se pulsa el botón del ratón. El botón puede valer GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON o GLUT_RIGHT_BUTTON, para asociarlo al botón izquierdo, central o derecho respectivamente.

void glutChangeToMenuEntry (int entrada, char *nombre, int valor):
Cambia la entrada (el parámetro entrada indica el índice de la misma, empezando en 1) por otra diferente. Esta función sirve para modificar una opción del menú actual. El parámetro entry nos indica la opción a modificar (por ejemplo, para modificar la primera, entry = 1), name será el nuevo nombre de la opción y value el nuevo identificador que se le pasará a la función controladora de menú.

void glutEstablishOverlay(void);
Establece la capa.

void glutUseLayer(GLenum layer);
Usar capa.

void glutRemoveOverlay(void);
Remueve la capa actual.

void glutPostOverlayRedisplay(void);
Mostra la capa siguiente.

void glutShowOverlay(void);
Mostrar capa.

void glutHideOverlay(void);
Muestra la textura de la capa.

void glutOverlayDisplayFunc(void (*func)(void));
Crea una funcion que devulve la capa a mostrar.

void glutSpaceballMotionFunc(void (*func)(int x, int y, int z));
Pone el movimiento del Spaceball en la ventana actual.

void glutSpaceballRotateFunc(void (*func)(int x, int y, int z));
Pone el Spaceball dependiendo la rotación en la ventana actual.

void glutSpaceballButtonFunc(void (*func)(int button, int state));
Pone el Spaceball en la ventana actual.

void glutButtonBoxFunc(void (*func)(int button, int state));
Pone la caja dial & button box a través de un callback en la ventana actual.

void glutDialsFunc(void (*func)(int dial, int value));
Pone la caja dial & button box a través de un callback en la ventana actual.

void glutTabletMotionFunc(void (*func)(int x, int y));
Coloca el teclado especial a través de un callback en la ventana actual.

void glutSetColor(int cell, GLfloat red, GLfloat green, GLfloat blue);
Pone el color de mapa entre la capa en uso y la actual ventana.

GLfloat glutGetColor(int cell, int component);
Regresa verde, rojo o azul de un color dado en el índice de color de mapa entre la capa en uso y la capa actual.

void glutCopyColormap(int win);
Copia el color del mapa para la capa en uso de una especifica ventana.

int glutLayerGet(GLenum info);
Regresa el estado de GLUT perteneciente a las capas de la ventana actual. La información es sobre:
GLUT OVERLAY ,GLUT LAYER IN USE, GLUT NORMAL, GLUT OVERLAY, GLUT HAS OVERLAY, GLUT TRANSPARENT INDEX, GLUT NORMAL DAMAGED, GLUT OVERLAY DAMAGED.

int glutDeviceGet(GLenum info);
Recupera informacion acerca del recurso de GLUT representado por enteros.
GLUT HAS KEYBOARD, GLUT HAS MOUSE, GLUT HAS SPACEBALL, GLUT HAS DIAL AND BUTTON BOX,
GLUT HAS TABLET, regresan No-cero si es viable, cero si no es viable.
GLUT NUM MOUSE BUTTONS Numeros de botones soportados por el mouse. Si no existe maouse regresa 0.
GLUT NUM SPACEBALL BUTTONS Numero de botones que soporta el Spaceball.
GLUT NUM BUTTON BOX BUTTONS Numero de botones que soporta el dial&buttonbox.
GLUT NUM Numero de selectores para la caja dial&button
GLUT NUM TABLET BUTTONS Numero de botones soportada por la tableta.

int glutGetModifiers(void);
Regresa la modificacion de las llaves de estado cuando ciertos callbacks son generados.
GLUT ACTIVE SHIFT si el modificador shift o caps fueron activados.
GLUT ACTIVE CTRL si fue presionado Ctrl.
GLUT ACTIVE ALT si fue modificado Alt.

int glutExtensionSupported(char *extension);
Ayuda a facilitar si algunas determinadas extensiones son soportadas por OpenGL.

void glutBitmapCharacter(void *font, int character);
Regresa el ancho en pixeles de un caracter tipo mapa de bits dependiendo de la fuente que puede ser:
GLUT BITMAP 8 BY 13 Fija una fuente donde cada cara ter tiene un rectangulo de tamaño 8 por 13 pixeles.
GLUT BITMAP 9 BY 15 Fija una fuente donde cada cara ter tiene un rectangulo de tamaño 9 por 15 pixeles.
GLUT BITMAP TIMES ROMAN 10 Proporcional al Times Roman tamaño 10.
GLUT BITMAP TIMES ROMAN 24 Proporcional al Times Roman tamaño 24.
GLUT BITMAP HELVETICA 10 Proporcional a la Helveltica tamaño 10.
GLUT BITMAP HELVETICA 12 10 Proporcional a la Helveltica tamaño 12.
GLUT BITMAP HELVETICA 18 10 Proporcional a la Helveltica tamaño 18.

int glutBitmapWidth(GLUTbitmapFont font, int character);
Regresa el ancho en pixeles de un caracter tipo mapa de bits dependiendo de la fuente.

void glutStrokeCharacter(void *font, int character);
Representa un caracter tipo stroke, con un definido font que puede ser:
GLUT STROKE ROMAN A proporciona una fuente tipo Romano su tamaño maximo es de 119.05 unidades y minimo de 33.33 unidades.
GLUT STROKE MONO ROMAN A .

int glutStrokeWidth(GLUTstrokeFont font, int character);
Regresa el ancho en pixeles de un caracter tipo stroke dependiendo del font.


REPORTE PRACTICA 4

En la práctica se hablo del doble buffering que en GLUT esta dado por DoubleBuffer, que indica el espacio de almacenamiento doble, en este espacio se almacenan datos y reduce el parpadeo en la imagen, ya que cuando se dibuja una imagen y se borra el tiempo de ejecución aumenta, con esta función el tiempo se reduce por que se tienen en lugar de 1 solo bufer se tienen dos.

Los parámetros de la función son los siguientes:

glutInitDisplayMode(GLUT_DOUBLEGLUT_RGBGLUT_DEPTH) ;

donde :

GLUT_DOUBLE : Evita parpadeo, doble buffer.
GLUT_RGB : Indica el color en rojo, verde y azul.
GLUT_DEPTH: Indica pruebas de profundidad, también llamado z buffer.

Como se ha visto en las practicas se ha utilizado la función glFlush(), esta función se encarga de vaciar el contenido del Frame Buffer en la pantalla de video.

Para el doble buffering se utiliza una función similar a glFlush() llamado glutSwapBuffers(), que se encarga de intercambiar los buffers, cuando se utiliza esta función, glFhush() es redundante y se puede omitir.

También se hablo de funciones como:

glClear(GL_COLOR_BUFFER_BITGL_DEPTH_BUFFER_BIT); que se encarga de limpiar la pantalla donde estan los píxeles.

glutPostRedisplay(); Genera un elemento de redibujado según las modificaciones, se fuerza el evento de redibujado.

glutSpecialFunc(); Que se utiliza para definir las teclas F1-F12, y otras especiales.


Estas funciones se explican más a detalle en el API_GLUT mostrado en este blog

domingo, 8 de abril de 2007

ALGORITMO MEJORADO
Void linea(int xo, yo, x1, y1)
{
int y=y0;
flot mint x=x0;
m=(y1-y0)/(x1-x0);
punto(x,y);if (m<0) m="m*(-1);
">do { x=x+1; y=y+m+0.5;
punto (x,y);
}while(y!=y1);