Previo 7

#include
#include
#include
#include
#include
/*parametros para el triangulo*/
static int prueba = 1;
static int prueba2 = 1;
static int prueba4 = 1;
static int win1;
static int win2;
static int win3;
static int xzoom = 0;
static int yzoom = 0;
static float px1=-2.5;
static float py1=-2.165;
static float px2=2.5;
static float py2=-2.165;
static float px3=0;
static float py3=2.165;
static float px = 0;
static float py = 0;
static float pcx = 0;
static float pcy = 0;
static float color1 = 0;
static float color2 = 0;
/*-----------------------------------*/
/*parametros para humanoide*/
static int posicionx = 0;
static int posiciony = 0;
static int posicionz = 0;
/*cabeza*/
static int cuelloy = 0;
/*brazo derecho*/
static int hombroderx = 0;
static int hombrodery = 0;
static int hombroderz = 90;
static int cododerz = 0;
/*brazo izquierdo*/
static int hombroizqx = 0;
static int hombroizqy = 0;
static int hombroizqz = -90;
static int codoizqz = 0;
/*pierna derecha*/
static int musloderx = 0;
static int muslodery = 0;
static int musloderz = 45;
static int rodilladerx = 0;
static int piedery = 0;
/*pierna izquierda*/
static int musloizqx = 0;
static int musloizqy = 0;
static int musloizqz = -45;
static int rodillaizqx = 0;
static int pieizqy = 0;
GLUquadricObj *sphereObj;
/*-------------------------------------*/
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void sierpinski (void)
{
int i= 0;
px = rand()%20;
py = rand()%20;
px = px/10;
py = py/10;
/*puntos del triangulo*/
glBegin(GL_POINTS);
glVertex2f(px1,py1);
glEnd();
glBegin(GL_POINTS);
glVertex2f(px2,py2);
glEnd();
glBegin(GL_POINTS);
glVertex2f(px3,py3);
glEnd();
glBegin(GL_POINTS);
glVertex2f(px,py);
glEnd();
/*puntos a calcular*/
do
{
prueba = rand()%3;
if(prueba == 0)
{
px = (px1 + px)/2;
py = (py1 + py)/2;
}
if(prueba == 1)
{
px = (px2 + px)/2;
py = (py2 + py)/2;
}
if(prueba == 2)
{
px = (px3 + px)/2;
py = (py3 + py)/2;
}
/*distancia entre el punto y el centro para los colores*/
pcx = px;
pcy = py + 0.72125;
pcx = pcx*pcx;
pcy = pcy*pcy;
color1 = sqrt(pcx+pcy);
color1 = color1/2.886;
color2 = 1.1 - color1;
glColor3f (color2,color1,0.0);
/*----------------------------------------------------*/
glBegin(GL_POINTS);
glVertex2f(px,py);
glEnd();
i++;
}while (i < 500000);
}
/*Humanoide y sus funciones*/
void cuborelleno(void)
{
glBegin(GL_QUADS);
glVertex3f(0.5,0.5,0.5);//v1
glVertex3f(-0.5,0.5,0.5);//v2
glVertex3f(-0.5,-0.5,0.5);//v3
glVertex3f(0.5,-0.5,0.5);//v4
glEnd();
glBegin(GL_QUADS);
glVertex3f(-0.5,0.5,-0.5);//v5
glVertex3f( 0.5,0.5,-0.5);//v6
glVertex3f(0.5,-0.5,-0.5);//v7
glVertex3f(-0.5,-0.5,-0.5);//v8
glEnd();
glBegin(GL_QUADS);
glVertex3f(-0.5,0.5,0.5);//v2
glVertex3f(-0.5,0.5,-0.5);//v5
glVertex3f(-0.5,-0.5,-0.5);//v8
glVertex3f(-0.5,-0.5,0.5);//v3
glEnd();
glBegin(GL_QUADS);
glVertex3f(0.5,0.5,0.5);//v1
glVertex3f(0.5,-0.5,0.5);//v4
glVertex3f( 0.5,-0.5,-0.5);//v7
glVertex3f(0.5,0.5,-0.5);//v6
glEnd();
glBegin(GL_QUADS);
glVertex3f(-0.5,0.5,-0.5);//v5
glVertex3f(-0.5,0.5,0.5);//v2
glVertex3f(0.5,0.5,0.5);//v1
glVertex3f( 0.5,0.5,-0.5);//v6
glEnd();
glBegin(GL_QUADS);
glVertex3f(0.5,-0.5,-0.5);//v7
glVertex3f(-0.5,-0.5,-0.5);//v8
glVertex3f(-0.5,-0.5,0.5);//v3
glVertex3f(0.5,-0.5,0.5);//v4
glEnd();
}
void cubohueco(void)
{
glBegin(GL_LINE_LOOP);
glVertex3f(0.5,0.5,0.5);//v1
glVertex3f(-0.5,0.5,0.5);//v2
glVertex3f(-0.5,-0.5,0.5);//v3
glVertex3f(0.5,-0.5,0.5);//v4
glEnd();
glBegin(GL_LINE_LOOP);
glVertex3f(-0.5,0.5,-0.5);//v5
glVertex3f( 0.5,0.5,-0.5);//v6
glVertex3f(0.5,-0.5,-0.5);//v7
glVertex3f(-0.5,-0.5,-0.5);//v8
glEnd();
glBegin(GL_LINE_LOOP);
glVertex3f(-0.5,0.5,0.5);//v2
glVertex3f(-0.5,0.5,-0.5);//v5
glVertex3f(-0.5,-0.5,-0.5);//v8
glVertex3f(-0.5,-0.5,0.5);//v3
glEnd();
glBegin(GL_LINE_LOOP);
glVertex3f(0.5,0.5,0.5);//v1
glVertex3f(0.5,-0.5,0.5);//v4
glVertex3f( 0.5,-0.5,-0.5);//v7
glVertex3f(0.5,0.5,-0.5);//v6
glEnd();
glBegin(GL_LINE_LOOP);
glVertex3f(-0.5,0.5,-0.5);//v5
glVertex3f(-0.5,0.5,0.5);//v2
glVertex3f(0.5,0.5,0.5);//v1
glVertex3f( 0.5,0.5,-0.5);//v6
glEnd();
glBegin(GL_LINE_LOOP);
glVertex3f(0.5,-0.5,-0.5);//v7
glVertex3f(-0.5,-0.5,-0.5);//v8
glVertex3f(-0.5,-0.5,0.5);//v3
glVertex3f(0.5,-0.5,0.5);//v4
glEnd();
}
void torso (int posx,int posy,int posz)
{
glTranslatef(0.0,1.5,0.0);
glScalef (0.75, 0.75, 0.75);
glRotatef(posx,1.0,0.0,0.0);
glRotatef(posy,0.0,1.0,0.0);
glRotatef(posz,0.0,0.0,1.0);
glTranslatef(0.0,0.0,0.0);
glPushMatrix();
glScalef (2.0, 3.0, 1.0);
cubohueco();
glPopMatrix();
}
void cara (int cuey)
{
glPushMatrix();
glRotatef(cuey,0.0,1.0,0.0);
glTranslatef(0.0,2.0,0.0);
//cubohueco();
gluSphere(sphereObj, 0.65, 12, 5);
glPopMatrix();
}
void muneca (void)
{
/*muñeca y palma*/
glTranslatef(0.0,0.0,0.0);
glRotatef(0,1.0,0.0,0.0);
glRotatef(0,0.0,1.0,0.0);
glRotatef(0,0.0,0.0,1.0);
glTranslatef(0.0,0.5,0.0);
glPushMatrix();
glScalef(1.0,1.0,0.33333);
cubohueco();
glPopMatrix();
}
void dedos(void)
{
/*dedo chito*/
glScalef(1.0,1.0,1.0);
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(-1.5,2.2,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,0.85,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.0,0.75,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo chiquito*/
/*dedo anular*/
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(-0.5,2.2,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.25,0.0);
glPushMatrix();
glScalef(1.0,1.75,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.0,0.75,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo anular*/
/*dedo medio*/
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(0.5,2.2,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.5,0.0);
glPushMatrix();
glScalef(1.0,2.25,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.0,0.75,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo medio*/
/*dedo indice*/
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(1.5,2.2,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.0,0.0);
glPushMatrix();
glScalef(1.0,1.5,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.0,1.25,0.0);
glPushMatrix();
glScalef(1.0,1.75,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.0,0.90,0.0);
glRotatef(0,1.0,0.0,0.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.0,0.75,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo indice*/
/*dedo gordo*/
glPushMatrix();
/*primera falange*/
glScalef(0.25,0.25,0.25);
glTranslatef(2.0,-1.25,0.0);
glRotatef(0,0.0,-1.0,0.0);
glRotatef(0,0.0,0.0,1.0);
glScalef(1.3,1.3,1.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.75,0.0,0.0);
glPushMatrix();
glScalef(1.0,1.0,1.0);
cubohueco();
glPopMatrix();
/*segunda falange*/
glTranslatef(0.9,0.0,0.0);
glRotatef(0,0.0,0.0,1.0);
gluSphere(sphereObj, 0.65, 12, 5);
glTranslatef(0.6,0.0,0.0);
glPushMatrix();
glScalef(0.75,1.0,1.0);
cubohueco();
glPopMatrix();
/*tercera falange*/
glTranslatef(0.75,0.0,0.0);
glRotatef(0,0.0,0.0,1.0);
gluSphere(sphereObj, 0.60, 12, 5);
glTranslatef(0.5,0.0,0.0);
glPushMatrix();
glScalef(0.75,1.0,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*fin dedo gordo*/
}
void mano(void)
{
glPushMatrix();
//glScalef(-1.0,1.0,1.0);
muneca();
dedos();
glPopMatrix();
}
void brazoderecho (int hombrodx,int hombrody,int hombrodz,int cododz)
{
/*brazo derecho*/
glPushMatrix();
glTranslatef(1.0,1.0,0.0);
glRotatef(hombrodx,1.0,0.0,0.0);
glRotatef(hombrody,0.0,1.0,0.0);
glRotatef(hombrodz,0.0,0.0,1.0);
glTranslatef(1.0,0.25,0.0);
glPushMatrix();
glScalef(2.0,0.5,1.0);
cubohueco();
glPopMatrix();
/*antebrazo derecho*/
glTranslatef(1.0,0.0,0.0);
glRotatef(cododz,0.0,0.0,1.0);
glTranslatef(1.0,0.0,0.0);
glPushMatrix();
glScalef(2.0,1.0,1.0);
cubohueco();
glPopMatrix();
/*mano derecha*/
glTranslatef(1.0,0.0,0.0);
glRotatef(-90,0.0,0.0,1.0);
gluSphere(sphereObj,0.25,12,5);
glTranslatef(0.0,0.25,0.0);
glPushMatrix();
glScalef(-0.5,0.5,1.0);
mano();
glPopMatrix();
glPopMatrix();/*brazo derecho completo*/
}
void brazoizquierdo (int hombroix,int hombroiy,int hombroiz,int codoiz)
{
/*brazo izquierdo*/
glPushMatrix();
glTranslatef(-1.0,1.0,0.0);
glRotatef(hombroix,1.0,0.0,0.0);
glRotatef(hombroiy,0.0,1.0,0.0);
glRotatef(hombroiz,0.0,0.0,1.0);
glTranslatef(-1.0,0.25,0.0);
glPushMatrix();
glScalef(2.0,0.5,1.0);
cubohueco();
glPopMatrix();
/*antebrazo izquierdo*/
glTranslatef(-1.0,0.0,0.0);
glRotatef(codoiz,0.0,0.0,1.0);
glTranslatef(-1.0,0.0,0.0);
glPushMatrix();
glScalef(2.0,1.0,1.0);
cubohueco();
glPopMatrix();
/*mano derecha*/
glTranslatef(-1.0,0.0,0.0);
glRotatef(90,0.0,0.0,1.0);
gluSphere(sphereObj,0.25,12,5);
glTranslatef(0.0,0.25,0.0);
glPushMatrix();
glScalef(0.5,0.5,1.0);
mano();
glPopMatrix();
glPopMatrix();/*brazo izquierdo completo*/
}
void piernaderecha(int muslodx,int muslody,int muslodz,int rodilladx,int piedy)
{
/*muslo derecho*/
glPushMatrix();
glTranslatef(0.665,-1.5,0.0);
glRotatef(muslodx,1.0,0.0,0.0);
glRotatef(muslody,0.0,1.0,0.0);
glRotatef(muslodz,0.0,0.0,1.0);
glTranslatef(0.0,-1.2,0.0);
glPushMatrix();
glScalef(0.68,2.4,1.0);
cubohueco();
glPopMatrix();
/*pantorrilla derecha*/
glTranslatef(0.0,-1.2,0.0);
glRotatef(rodilladx,1.0,0.0,0.0);
glTranslatef(0.0,-1.2,0.0);
glPushMatrix();
glScalef(1.0,2.4,1.0);
cubohueco();
glPopMatrix();
/*pie derecho*/
glTranslatef(0.0,0.-1.25,0.0);
glRotatef(piedy,0.0,1.0,0.0);
glTranslatef(0.25,-0.35,0.0);
glPushMatrix();
glScalef(1.5,0.75,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*pie derecho completo*/
}
void piernaizquierda(int musloix,int musloiy,int musloiz,int rodillaix,int pieiy)
{
/*muslo izquierdo*/
glPushMatrix();
glTranslatef(-0.665,-1.5,0.0);
glRotatef(musloix,1.0,0.0,0.0);
glRotatef(musloiy,0.0,1.0,0.0);
glRotatef(musloiz,0.0,0.0,1.0);
glTranslatef(0.0,-1.2,0.0);
glPushMatrix();
glScalef(0.68,2.4,1.0);
cubohueco();
glPopMatrix();
/*pantorrilla izquierda*/
glTranslatef(0.0,-1.2,0.0);
glRotatef(rodillaix,1.0,0.0,0.0);
glTranslatef(0.0,-1.2,0.0);
glPushMatrix();
glScalef(1.0,2.4,1.0);
cubohueco();
glPopMatrix();
/*pie izquierdo*/
glTranslatef(0.0,0.-1.25,0.0);
glRotatef(pieiy,0.0,1.0,0.0);
glTranslatef(-0.25,-0.35,0.0);
glPushMatrix();
glScalef(1.5,0.75,1.0);
cubohueco();
glPopMatrix();
glPopMatrix();/*pierna izquierda completo*/
}
void humanoide (int px,int py,int pz,int cy,int hdx,int hdy,int hdz,int cdz,int hix,int hiy,int hiz,int ciz,
int mdx,int mdy,int mdz,int rdx,int pdy,int mix,int miy,int miz,int rix,int piy)
{
torso(px,py,pz);
cara(cy);
brazoderecho(hdx,hdy,hdz,cdz);
brazoizquierdo(hix,hiy,hiz,ciz);
piernaderecha(mdx,mdy,mdz,rdx,pdy);
piernaizquierda(mix,miy,miz,rix,piy);
}
/*----------------------------------------*/
void display1(void)
{
srand(time(NULL));
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity ();
gluLookAt (0.0,0.0,5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glClear (GL_COLOR_BUFFER_BIT);
sierpinski();
glFlush();
}
void display2(void)
{
srand(time(NULL));
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity ();
gluLookAt (0.0,0.0,15.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glClear (GL_COLOR_BUFFER_BIT);
glPushMatrix();
glScalef(4,4,1);
sierpinski();
glPopMatrix();
glFlush();
}
void display3(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity ();
gluLookAt (0.0,0.0,10.0,0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glPushMatrix();
sphereObj = gluNewQuadric();
gluQuadricDrawStyle(sphereObj, GLU_LINE);
humanoide(posicionx,posiciony,posicionz,cuelloy,
hombroderx,hombrodery,hombroderz,cododerz,
hombroizqx,hombroizqy,hombroizqz,codoizqz,
musloderx,muslodery,musloderz,rodilladerx,piedery,
musloizqx,musloizqy,musloizqz,rodillaizqx,pieizqy);
glPopMatrix();
glFlush ();
}
void reshape1 (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);
}
void reshape2 (int w, int h)
{
glViewport (xzoom, yzoom, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}
void reshape3 (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);
}
void animacion(void)
{
int i,j;
for(j=0;j<45;j++)
{
display3();
hombroderz = (hombroderz +2)%95;
hombroizqz = (hombroizqz -2)%95;
musloderz = (musloderz -1)%50;
musloizqz = (musloizqz +1)%50;
for (i=0;i<3500000;i++)
{
}
}
for(j=0;j<45;j++)
{
display3();
hombroderz = (hombroderz -2)%90;
hombroizqz = (hombroizqz +2)%90;
musloderz = (musloderz +1)%50;
musloizqz = (musloizqz -1)%50;
for (i=0;i<3500000;i++)
{
}
}
}
void idle3(void)
{
animacion();
display3();
}
/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
case 'q':
glutPostRedisplay();
break;
}
}
void mouse(int button, int state, int x, int y)
{
if (state == GLUT_DOWN)
{
if ((glutGetWindow() == win1) && button == GLUT_LEFT_BUTTON)
{
xzoom = 255 - x;
yzoom = y - 255;
printf("%d, %d \n",x, y);
glutInitWindowSize (500, 500);
glutInitWindowPosition (700, 100);
win2 = glutCreateWindow ("Ventana 2");
init();
glutDisplayFunc(display2);
glutReshapeFunc(reshape2);
glutSetWindow(win2);
glutIdleFunc(NULL);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
}
else if ((glutGetWindow() == win2) && (button == GLUT_RIGHT_BUTTON)){
glutIdleFunc(NULL);
glutDestroyWindow(win2);
}
}
if (state == GLUT_UP)
{
if ((glutGetWindow() == win1) && button == GLUT_RIGHT_BUTTON)
{
printf("%d, %d \n",x, y);
glutInitWindowSize (800, 800);
glutInitWindowPosition (500, 50);
win3 = glutCreateWindow ("Ventana 3");
init();
glutDisplayFunc(display3);
glutReshapeFunc(reshape3);
glutSetWindow(win3);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutIdleFunc(idle3);
}
else if ((glutGetWindow() == win3) && (button == GLUT_RIGHT_BUTTON)){
glutIdleFunc(NULL);
glutDestroyWindow(win3);
//glutSetWindow(win1);
}
}
}
int main(int argc, char** argv)
{
//Configuracion de la primera ventana
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
win1 =glutCreateWindow ("Fractal");
glutSetWindow(win1);
init ();
glutDisplayFunc(display1);
glutReshapeFunc(reshape1);
glutIdleFunc(NULL);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMainLoop();
return 0;
}

Practica 6

reporte de la practica 6


#include
#include
void timer(int value);
void init(void);
void display(void);
void reshape (int w, int h);
void mouse(int button, int state, int x, int y);
void timer(int value);
void idle();
int opcion=0;
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glClear (GL_COLOR_BUFFER_BIT);
glShadeModel (GL_FLAT);
}
void display(void)
{
float a,b,c,x,y,ancho,alto;
int i;
a=rand()%10;
a=a/10;
b=rand()%10;
b=b/10;
c=rand()%10;
c=c/10;
glColor3f (a, b, c);
glLoadIdentity ();
gluLookAt (2.0,0.0,6.0,2.0,0.0, 0.0, 0.0, 5, 0.0);
glPushMatrix();
glTranslatef(-0.5,-2.3,0.0);
switch(opcion)
{
case 0:
glBegin(GL_LINE_LOOP);
for (i=0;i<2;i++)
glVertex3f(rand()%6,rand()%6,1);
glEnd();
break;
case 1:
glBegin(GL_LINE_LOOP);
for (i=0;i<3;i++)
glVertex3f(rand()%6,rand()%6,1);
glEnd();
break;
case 2:
glBegin(GL_LINE_LOOP);
x=rand()%6;
y=rand()%6;
ancho=rand()%6;
alto=rand()%6;
glVertex3f(x,y,1);
glVertex3f(ancho,y,1);
glVertex3f(ancho,alto,1);
glVertex3f(x,alto,1);
glEnd();
break;
default:
break;
}
glPopMatrix();
glFlush ();
}

void mouse(int button, int state, int x, int y)
{
if (button == GLUT_LEFT_BUTTON)
{
if(state == GLUT_DOWN)
{
opcion++;
if(opcion==3)
opcion=0;
}
}
}
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);
}
void idle()
{
int j;
for(j=0;j<30000000;j++){}
display();
}
void timer(int value)
{
int j;
glutTimerFunc(5000,timer,1);
glClear (GL_COLOR_BUFFER_BIT);
for(j=0;j<30000000;j++){}
display();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (700, 700);
glutInitWindowPosition (100, 100);
glutCreateWindow ("Reporte");
init ();
glutIdleFunc(idle);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutTimerFunc(5000,timer,1);
glutMainLoop();
return 0;
}

Tarea 6

Las curvas en NURBS estan definidas por su orden, un grupo de puntos de control con peso, y un vector de nudo, las curvas y superficies en NURBS esta generalizadas por las B-splines y las curvas y superficies de Bézier, la diferencia primordial radica en el pesado de los puntos de control, esto hace a las curvas en NURBS curvas racionales (las curvas no racionales B-splines son un caso especial de las curvas racionales B-splines), las curvas NURBS evolucionan en una dirección parametrica, generalmente llamada s o u, y las superficies NURBS evolucionan en dos direcciones parametrica, llamdas s y t o u y v.

Al evaluar una curva NURB en varios valores del parámetro. La curva puede ser representada en espacios de dos o tres dimensiones cartesianos. De la misma forma al evaluar una superficie NURB en varios valores de los dos parámetros, la superficie podrá ser representada en un espacio cartesiano.

El vector nudo es una secuencia de valores parametricos que determinan donde y como los puntos de control afectaran a la curva NURB, el número de nudos es siempre igual al número de puntos de control mas el grado de la curva mas uno. Necesarios para cálculos internos, los nudos no son generalmente útiles para los usuarios de software de modelado. Por lo tanto, muchas aplicaciones no hacen a los nudos editables o siquiera visibles.

Fuentes:

http://en.wikipedia.org/wiki/NURBS

Tarea 5

Algoritmo de Bresenham pata rectas con pendientes mayores a uno

Primero calculamos los errores , en clase se vio para rectas con pendientes menores a 1, en el caso de las pendientes mayores a uno se evalúan dos puntos diferentes, el trasladado en el norte y el del noreste

F(x + 1/2, y +1) = A(x +1/2) + B (y+1) + C= Ax + 1/2A + By + B + C

Si la dirección es N

F(x + 1/2, y +2) = A(x +1/2) + B (y+2) + C= Ax + 1/2A + By + 2B + C

Error en N

DN = Ax + 1/2A + By + 2B + C – (Ax + 1/2A + By + B+ C) = B

Si la dirección es NE

F(x + 3/2, y +2) = A(x +3/2) + B (y+2) + C= Ax + 3/2A + By + 2B + C

Error en NE

DN = Ax + 3/2A + By + 2B + C – (Ax + 1/2A + By + B + C) = A + B

El delta cero es

F(x0 + 1/2, y0 +1) = A(x0 +1/2) + B (y0+1) + C= Ax0 + 1/2A + By0 + B + C =
= 1/2 A + B

Algoritmo:

void lineadeBresenham(int x0, y0, x1, y1)
{
int Dx = x1 – x 0;
int Dy = y1 – y 0;
int m = Dy / Dx;
int x = x0;
int y = y0;
int D0a = 2 Dy – Dx;
int D0b = Dy – 2Dx;
int DE = 2 Dy;
int DNE = 2 (Dy-Dx);
int DN = -2DX;
int D;
if (m < = 1)
{
D = D0a
While (x != x1){
If (D <= 0)
{
Punto (x,y);
x = x +1;
D = D + DE;
}
else
{
Punto (x,y);
x = x +1;
y = y + 1;
D = D + DNE
}
}
}
else
{
D = D0b;
While (y != y1){
If (D <= 0)
{
Punto (x,y);
y = y +1;
D = D + DN;
}
else
{
Punto (x,y);
x = x +1;
y = y + 1;
D = D + DNE
}
}
}
}

Previo 6

Todas las instrucciones de GLUT

glutInit

Uso

void glutInit(int *argcp, char **argv)

Donde argcp es un apuntador a la variable sin modificar argc. Como regreso de esta función el valor al que apunta argcp es actualizado.

El parámetro argv es para la variable sin modificar de main argv. Como el parámetro anterior, actualiza el valor de argv.

Descripción

El comando glutInit inicializa la librería de GLUT y negocia una sesión con el sistema de ventana. También procesa opciones de la línea de comando.

glutInitWindowPosition y glutInitWindowSize

Uso

void glutInitWindowSize(int width, int height);
void glutInitWindowPosition(int x, int y);

Donde width es el ancho de la ventana y height la altura en píxeles.
X y Y responden a las coordenadas de la ventana cuando se crea.

Descripción

Estas funciones fijan los parámetros para la posición inicial y el tamaño de la ventana que se crea

glutInitDisplayMode

Uso

void glutInitDisplayMode(unsigned int mode);

Donde mode es la opción de máscara de bit deseada (la descripción de éstas se pueden encontrar en la fuente de referencia)
Las máscaras son:
GLUT_RGBA
GLUT_RGB
GLUT_INDEX
GLUT_SINGLE
GLUT_DOUBLE
GLUT_ACCUM
GLUT_ALPHA
GLUT_DEPTH
GLUT_STENCIL
GLUT_MULTISAMPLE
GLUT_STEREO
GLUT_LUMINANCE

Descripción

Esta función fija el modo despliegue inicial. Este modo es para la creación de ventanas de alto nivel, subventanas y capas para determinar el display de OpenGL para la ventana que se va a crear.

glutMainLoop

Uso

void glutMainLoop(void);

Descripción

Entra al loop de proceso de eventos. Esta rutina debe ser llamada al menos una vez en un programa de GLUT. Una vez llamada, esta rutina nunca va a retornar, sólo va a llamar todas las callbacks o llamadas de retorno que se hayan registrado.

glutCreateWindow

Uso

int glutCreateWindow(char *name);

Descripción

Crea una ventana de alto nivel. El nombre de la ventana es dado por la variable name. El estado de despliegue o display de una ventana es mostrada por la ventana inicialmente, pero el estado de despliegue no actúa hasta que se entra al ciclo generado por la función glutMainLoop. Esto quiere decir que no se puede renderizar efectivamente a esta ventana hasta que se haya entrado al ciclo.

glutCreateSubWindow

Uso

int glutCreateSubWindow(int win, int x, int y, int width, int height);

Donde se tiene que especificar el nombre de la ventana a la cual se le quiera agregar la subventana (parámetro win). Los parámetros X y Y responden a la ubicación de la subventana dentro de la ventana original. Widht y Heigth especifican respectivamente el ancho y alto de esta subventana.

Descripción

Crea una sub ventana a partir de los parámetros que obtiene.
El estado de despliegue o display de la subventana es mostrada inicialmente, pero el estado de despliegue no actúa hasta que se entra al ciclo generado por la función glutMainLoop. Es similar a la utilización de la función glutCreateWindow.

glutSetWindow y glutGetWindow

Uso

void glutSetWindow(int win);
int glutGetWindow(void);

Donde win es el identificador de la ventana.

Descripción

glutSetWindow fija la ventana actual, glutGetWindow regresa el identificador de la ventana actual. Si no existen ventanas o la ventana actual fue destruida, glutGetWindow regresa el valor de 0. glutSetWindow no modifica la capa en uso para la ventana, esto se realiza mediane la función glutUseLayer.

glutDestroyWindow

Uso

void glutDestroyWindow(int win);

Descripción

Destruye a la ventana determinada por el parámetro win. Destruye también el contexto asociado por OpenGL, el mapa de colores lógico y las capas y estados relacionados. Cualquier subventana de la ventana destruida son tambien destruidas. SI la ventana a destruir es la actual, glutGetWindow regresa el valor de 0.

glutPostRedisplay

Uso

void glutPostRedisplay (void)

Descripción

Marca el plano normal de la ventana actual según se necesite ser re desplegado. En la próxima iteración a través de glutMainLoop se llamará la llamada de retorno o callback para re desplegar el plano normal de la ventana

Mark the normal plane of current window as needing to be redisplayed. The next iteration through glutMainLoop, the window's display callback will be called to redisplay the window's normal plane. Multiple calls to glutPostRedisplay before the next display callback opportunity generates only a single redisplay callback. glutPostRedisplay may be called within a window's display or overlay display callback to re-mark that window for redisplay.

Logically, normal plane damage notification for a window is treated as a glutPostRedisplay on the damaged window. Unlike damage reported by the window system, glutPostRedisplay will not set to true the normal plane's damaged status (returned by glutLayerGet(GLUT_NORMAL_DAMAGED).

glutSwapBuffers

Uso

void glutSwapBuffers(void);

Descripción

Realiza un intercambio de buffer en la capa en uso para la ventana actual. Específicamente, hace que el contenido del buffer trasero de la capa en uso se convierta en contenido del buffer frontal. En este paso el contenido del buffer trasero se considera cono undefined o indefinido. La actualización usualmente se realiza durante el re-trazado vertical del monitor, en vez de ser realizado inmediatamente después de llamar a la función glutSwapBuffers. Antes de retornar, esta función realiza un glFlush. Los comandos subsecuentes de OpenGL pueden ser ordenados inmediatamente después de llamar a la función, pero no son ejecutados hasta que el intercambio de buffers se complete.

glutPositionWindow

Uso

void glutPositionWindow(int x, int y);

Descripción

Solicita un cambio en la posición de la ventana actual. Para ventanas de alto nivel los parámetros de X y Y son offsets de píxeles del origen de la pantalla. Para subventanas, la X y la Y son offsets de píxel de la ventana padre. Las solicitudes hechas por glutPositionWindow no son procesadas inmediatamente, son ejecutadas después de regresar al loop de evento principal. Para el caso de ventanas de alto nivel, esta función es considerada sólo como una petición para posicionar la ventana. El sistema de ventanas es libre de aplicar sus propias políticas para la colocación de ventanas de alto nivel; la intención es que estas ventanas puedan ser re-posicionadas de acuerdo a los parámetros de glutPositionWindow.

glutReshapeWindow

Uso

void glutReshapeWindow(int width, int height);

Donde width es el ancho nuevo de la ventana y height la nueva altura.

Descripción

Realiza una petición de cambio de tamaño en la ventana actual. Los parámetros width y height son dados en píxeles y deben ser valores positivos.

Al igual que la función anterior, las solicitudes no son procesadas inmediatamente y para ventanas de alto nivel se considera como una petición de modificar la ventana.

glutFullScreen

Uso

void glutFullScreen(void);

Descripción

Solicita que la ventana actual se haga de tamaño de la pantalla completa. El concepto de ventana completa varía de sistema dependiendo del sistema de ventana. La idea es hacer la ventana tan larga como sea posible y deshabilitar cualquier decoración o borde de ventana añadidos al sistema de ventanas. El largo y ancho de la ventana no se garantiza que sean los mismos que los de la pantalla, pero esa es la intención de hacer la ventana de tamaño completo.

Esta funció está definida sólo para ventanas de alto nivel. Al igual que las dos instrucciones anteriores, no se procesa inmediatamente.

glutPopWindow y glutPushWindow

Uso

void glutPopWindow(void);
void glutPushWindow(void);

Descripción

Estos comandos funcionan para los dos niveles de ventanas, principales y subventanas. El efecto de hacer un push y pop en las ventanas no se realiza inmediatamente. En vez de eso, se salva la ejecución hasta regresar al ciclo de evento de GLUT. Subsecuentemente, estas instrucciones solicitan un reemplazo de la petición anteriormente guardada para esa ventana. El efecto de hacer pop y push en ventanas de alto nivel es a consideración de la política del sistema de ventanas para apilar las mismas.

glutShowWindow, glutHideWindow, glutIconifyWindow

Uso

void glutShowWindow(void);
void glutHideWindow(void);
void glutIconifyWindow(void);

Descripción

glutShowWindow muestra la ventana actual.
glutHideWindow oculta la ventana actual.
glutIconifyWindow minimiza la ventana actual.

glutSetWindowTitle, glutSetIconTitle

Uso

void glutSetWindowTitle(char *name);
void glutSetIconTitle(char *name);

name: deberá conformarse por una cadena de caracteres ASCII.

Descripción

glutSetWindowTitle pone la barra de título en la ventana
glutSetIconTitle pone la barra de título en la ventana minimizada

glutSetCursor

Uso

void glutSetCursor(int cursor);

cursor
Nombre de la imagen del cursor a cambiar.
GLUT_CURSOR_RIGHT_ARROW
Flecha que señala encima y a la derecha.
GLUT_CURSOR_LEFT_ARROW
Flecha que señala encima y a la izquierda.
GLUT_CURSOR_INFO
Señalador de mano.
GLUT_CURSOR_DESTROY
Cráneo y huesos encrusijados.
GLUT_CURSOR_HELP
Marca de pregunta.
GLUT_CURSOR_CYCLE
Flecha que está rotando en un círculo.
GLUT_CURSOR_SPRAY
Lata de aerosol.
GLUT_CURSOR_WAIT
Reloj.
GLUT_CURSOR_TEXT
Cursor para apuntar a la insercion de texto.
GLUT_CURSOR_CROSSHAIR
Cortador.
GLUT_CURSOR_UP_DOWN
Puntero bidireccional arriba y abajo.
GLUT_CURSOR_LEFT_RIGHT
Puntero bidireccional izquierda y derecha
GLUT_CURSOR_TOP_SIDE
Flecha que upunta a un lado superior.
GLUT_CURSOR_BOTTOM_SIDE
Flecha que apunta a un lado inferior.
GLUT_CURSOR_LEFT_SIDE
Flecha que apunta a un lado izquierdo.
GLUT_CURSOR_RIGHT_SIDE
Flecha que apunta a un lado derecho.
GLUT_CURSOR_TOP_LEFT_CORNER
Flecha que apunta a la esquina superior izquierda.
GLUT_CURSOR_TOP_RIGHT_CORNER
Flecha que apunta a la esquina superior derecha.
GLUT_CURSOR_BOTTOM_RIGHT_CORNER
Flecha que apunta a la esquina inferior izquierda.
GLUT_CURSOR_BOTTOM_LEFT_CORNER
Flecha que apunta a la esquina inferior derecha.
GLUT_CURSOR_FULL_CROSSHAIR
Cursor de pantalla completa del cortador.
GLUT_CURSOR_NONE
Cursor invisible.
GLUT_CURSOR_INHERIT
Uso del cursor padre.

Descripción

glutSetCursor cambia la imagen del cursor de la ventana actual.

glutEstablishOverlay

Uso

void glutEstablishOverlay(void);

Descripción

glutEstablishOverlay: establece un recubrimiento (si es posible) para la ventana actual. El modo de despliegue solicitado para el recubrimiento es determinado por el modo inicial de despliegue.

glutLayerGet(GLUT_OVERLAY_POSSIBLE): puede ser llamado para determinar si un recubrimiento es posible en la ventana actual con el modo inicial de despliegue actual. No intente establecer un recubrimiento cuando no es posible, ya que GLUT terminará el programa.

Si glutEstablishOverlay es llamado cuando un recubrimiento ya existe, el recubrimiento existente es removido primero, y entonces un nuevo recubrimiento es establecido.

glutUseLayer

Uso

void glutUseLayer(GLenum layer);
layer.- Cualquier GLUT_NORMAL o GLUT_OVERLAY, selecciona el plano normal o el recubrimiento respectivamente.

Descripción

glutUseLayer: cambia la capa en uso por ventana para la ventana actual, seleccionando cualquier plano normal o recubrimiento. El recubrimiento debe sólo ser especificado si es que existe, sin embargo una ventana sin recubrimiento puede todavía llamar a glutUseLayer(GLUT_NORMAL). Los comandos OpenGL para ventanas están dirigidos a la actual capa en uso.

Para saber la capa en uso en un ventana puede llamar a glutLayerGet(GLUT_LAYER_IN_USE).

glutRemoveOverlay

Uso

void glutRemoveOverlay(void);

Descripción

glutRemoveOverlay remueve el recubrimiento (si es que existe). Es seguro llamar a glutRemoveOverlay incluso si no hay un recubrimiento establecido actualmente, no hará nada en ese caso. Implícitamente, la capa en uso de la ventana cambia al plano norma inmediatamente un vez que haya sido eliminado el recubrimiento.

Si el programa intenta reestablecer el recubrimiento mas tarde, es típicamente mas rápido y hacienda uso de menos recursos utilizar glutHideOverlay and glutShowOverlay que simplemente cambia el estado de despliegue del recubrimiento.

glutPostOverlayRedisplay

Uso

void glutPostOverlayRedisplay(void);

Descripción

Marca el recubrimiento de la ventana actual como necesitando ser re-desplegado. La siguiente iteración a través de glutMainLoop, el recubrimiento de la ventana desplegará el callback (o simplemente el despliegue del callback si no hay un recubrimiento registrado en el despliegue del callback) será llamad a re-desplegar el plano del recubrimiento de la ventana. Llamadas múltiples con glutPostOverlayRedisplay antes de dar oportunidad al siguiente despliegue del callback(o la oportunidad al despliegue del callback con el recubrimiento si es que se registra alguno) se genera olamente un único re-despliegue. glutPostOverlayRedisplay podrá ser llamado dentro despliegue del callback o recubrimiento de la ventana y así remarcar esa ventana para su re-despliegue.

Lógicamente, Una notificación de daños de un recubrimiento para una ventana se trabaja con glutPostOverlayRedisplay sobre la ventana dañada. Diferente al daño reportado por sistema de la ventana, glutPostOverlayRedisplay no fijará el verdadero estado de daño del recubrimiento (retornado por glutLayerGet(GLUT_OVERLAY_DAMAGED)).

glutShowOverlay, glutHideOverlay

Uso

void glutShowOverlay(void);
void glutHideOverlay(void);

Descripción

glutShowOverlay muestra el recubrimiento de la ventana actual; glutHideOverlay oculta el recubrimiento. El efecto de mostrar u ocultar un recubrimiento tiene lugar inmediatamente. Note que glutShowOverlay no mostrará realmente el recubrimiento a menos de que la ventana también sea mostrada (e incluso una ventana mostrada podrá ser ocultada por otras ventanas, a tal grado ocultando el recubrimiento). Es típico, más rápido y hacienda uso de menos recursos del sistema utilizar estas rutinas para controlar el estado despliegue de un recubrimiento a quitar y reestablecer el recubrimiento.

glutCreateMenu

Uso

int glutCreateMenu(void (*func)(int value));
func..- La función callback para el menú es llamada cuando una entrada del menú se selecciona. El valor pasado al callback es determinado por el valor de la selección de la entrada del menú.

Descripción

glutCreateMenu crea un nuevo menú pop-up y retorna un único identificador entro pequeño. El rango asignación a los identificadores inicia en uno. El rango identificador de menú es independiente de el rango identificador de ventana. Implícitamente, el menú actual es fijado a es menú creado nuevamente. Este identificador de menú puede ser usado llamando a glutSetMenu.

Cuando el menú callback es llamado porque una entrada es seleccionada para el menú, el menú actual será implícitamente fijado a el menú con la entrada seleccionada antes el callback es hecho.

glutSetMenu, glutGetMenu

Uso

void glutSetMenu(int menu);
int glutGetMenu(void);
menú.- El identificador del menú para hacer el menú actual.

Descripción

glutSetMenu fija el menú actual; glutGetMenu devuelve el identificador del menú actual. Si no existen menús o el menú anterior fue eliminado, glutGetMenu devuelva cero.

glutDestroyMenu

Uso

void glutDestroyMenu(int menu);
menú.- El identificador del menú a destruir.

Descripción

glutDestroyMenu destruye el menú especificado por el argumento menú. Si el argumento menú fuera el del menú actual, el menú actual se convierte en inválido y glutGetMenu devolverá cero.

glutAddMenuEntry

Uso

void glutAddMenuEntry(char *name, int value);
name.- Cadena de caracteres ASCII a desplegar en la entrada del menu.
Value.- Valor a devolver a la función callback del menú si la entrada del menú es seleccionada.

Descripción

glutAddMenuEntry agrega una entrada de menú en la ultima parte del menú actual. La cadena name se desplegará para la entrada agregada nuevamente. Si la entrada de menú es seleccionada por el usuario, el callback del menú será llamado pasando value como parámetro de callback.

glutAddSubMenu

Uso

void glutAddSubMenu(char *name, int menu);
name.- Cadena de caracteres ASCII a desplegar en el objeto menu del cual se deriva el sub-menu.
menu .-Identificador de el menú del que se va a derivar este sub-menú.

Descripción

glutAddSubMenu agrega un sub-menu activador en el fondo del menu actual. La cadena name sera desplegada para el sub-menu activador agregado nuevamente. Si el sub-menu activador es incorporado, el sub-menú será numerado por el argumento menu y será colocado en cascada, permitiendo así que los objetos del sub-menú sean seleccionados.

glutChangeToMenuEntry

Uso

void glutChangeToMenuEntry(int entry, char *name, int value);
entry.- Índice de los artículos de menú en el menú actual (1 es el nivel más alto en un articulo de menú).
name .-Cadena de caracteres ASCII a desplegar en la entrada del menú.
value .-Valor a devolver a la función callback del menú si la entrada del menú es seleccionada.

Descripción

glutChangeToMenuEntry cambia la entrada de menú especificada en el menú actual. El parámetro entry determina cual artículo del menú debe ser cambiado, con uno siendo el de más alto nivel. entry necesita estar entre 1 y glutGet(GLUT_MENU_NUM_ITEMS) inclusive. El elemento del menú a cambiar no tiene que ser ya una entrada del menú. La cadena name será desplegada para la entrada de menú cambiada nuevamente. El valor value será devuelto al callback del menú si esta entrada del menú es seleccionada.

glutChangeToSubMenu

Uso

void glutChangeToSubMenu(int entry, char *name, int menu);
entry .-Índice de los artículos de menú en el menú actual (1 es el nivel más alto en un articulo de menú).
name .-Cadena de caracteres ASCII a desplegar en la entrada del menú.
value .-Valor a devolver a la función callback del menú si la entrada del menú es seleccionada.

Descripción

glutChangeToSubMenu cambia el elemento del menú especificado en el menú actual dentro de un sub-menú activador. El parámetro entry determina cual elemento del menú debe ser cambiado, con un elemente estando en el nivel mas alto. entry necesita estar entre 1 y glutGet(GLUT_MENU_NUM_ITEMS) incluso. El elemento del menú a cambiar no tiene ya que ser un sub-menú activador. La cadena name será desplegada para el sub-menú activador cambiado nuevamente. El parámetro menú es el identificador por nombre del sub-menú colocado en cascada nuevamente.

glutRemoveMenuItem

Uso

void glutRemoveMenuItem(int entry);
entry .-Índice de los artículos de menú en el menú actual (1 es el nivel más alto en un articulo de menú).

Descripción

glutRemoveMenuItem elimina el elemento de la entrada del menú sin importar que sea una entrada de menu o un activador de sub-menú. entry necesita estar entre 1 y glutGet(GLUT_MENU_NUM_ITEMS) incluso. Los elementos del menú debajo del elemento del menú eliminado son renumerados.

glutAttachMenu, glutDetachMenu

Uso

void glutAttachMenu(int botón);
void glutDetachMenu(int botón);
botón .- el botón a adjuntar o quitar el menú.

Descripción

glutAttachMenu adjunta un boton del mouse a la ventana actual, con el identificador del menú activo; glutDetachMenu quita el botón adjuntado del mouse a la ventana activa. Al adjuntar un menú identificador hacia un botón, el menú nombrado saldrá cuando el usuario presione el botón especificado. El valor botón debe ser uno de los siguientes: GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON, and GLUT_RIGHT_BUTTON. Note que el menú esta adjuntado al botón mediante un identificador y no mediante una referencia.

glutDisplayFunc

Uso

void glutDisplayFunc(void (*func)(void));
func .- la nueva función de display

Descripción

glutDisplayFunc dispone la función de display para la ventana actual. Cuando GLUT determina que el plano normal para la ventana necesita ser refrescada, el display callback de la ventana será llamado. Antes de la llamada, la ventana actual será dispuesta a la ventana que necesita ser refrescada y (si ninguna función de overlay display callback es registrada) la capa en uso es colocada en el plano normal. La función display callback es llamada sin ningún parámetro. Toda la región del plano normal deberá ser refrescada en respuesta a la llamada
GLUT determina cuando la función display callback deberá ser activada, basándose en el estado de refresco de la ventana. El estado de refresco para la ventana puede ser o explicitito llamando la función glutPostRedisplay o implícito como resultado de un reporte de daños de ventana, llamado por el sistema de ventanas.

glutOverlayDisplayFunc

Uso

void glutOverlayDisplayFunc(void (*func)(void));
func.- la nueva función overlay display callback.

Descripción

glutDisplayFunc dispone la función overlay display callback para la ventana actual. La función overlay display callback es funconalmente la misma que display callback excepto que la función overlay display callback es usada para refrescar el overlay de la ventana.
GLUT determina cuando la función overlay display callback deberá ser activada, basándose en el estado de refresco de la ventana. El estado de refresco para la ventana puede ser o explicitito llamando la función glutPostOverlayRedisplay o implícito como resultado de un reporte de daños de ventana, llamado por el sistema de ventanas.

glutReshapeFunc

Uso

void glutReshapeFunc(void (*func)(int largo, int alto));
func.- la nueva función redimensionamiento

Descripción

glutReshapeFunc dispone la función de redimensionamiento para la ventana actual. La función de redimensionamiento es activada cuando una ventana es redimensionada. Esta también es llamada inmediatamente antes de la primera función display callback dela ventana, después de que la venta es creada o en cualquier momento que un overlay para la ventana es establecido. El largo y la altura son parámetros de la función y especifican el tamaño de la nueva ventana en píxeles.

glutKeyboardFunc

Uso

void glutKeyboardFunc(void (*func)(unsigned char tecla,
int x, int y));
func.- la nueva función de teclado

Descripción

glutKeyboardFunc dispone la función de telado para la ventan actual. Cuando el usuario teclea en la ventana, cada tecla presionada genera un carácter ASCII el cual generará un una función de teclado. El parámetro tecla es el carácter ASCII generado. El estado de teclas modificadoras como Shift no pueden ser determinadas directamente; su único efecto será al regresar un dato ASCII los parámetros x y y indican la posición de mouse en coordenadas relativas dentro de la ventana cuando la tecla fue presionada. Cuando una nueva ventana es creada, no hay ninguna función de teclado asignada, y todos los caracteres ASCII creados en la ventana serán ignorados.

glutMouseFunc

Uso

void glutMouseFunc(void (*func)(int botón, int estado,
int x, int y));
func.- la nueva función del mouse

Description

glutMouseFunc dispone la función del mouse para la ventana actual. Cuando un usuario presiona y suelta un botón del mouse dentro de la ventana, cada presionada y cada soltada generan una función del mouse. El parámetro botón es uno de los siguientes GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON, or GLUT_RIGHT_BUTTON. Para sistemas con mouse de solo 2 botones, no será posible generar el estado GLUT_MIDDLE_BUTTON. Y para los sistemas con un solo botón de mouse, solo podra utilizar el parámetro GLUT_LEFT_BUTTON. El parámetro estado es GLUT_UP o GLUT_DOWN indicando que fue generado debido al presionar o soltar el botón respectivamente, los parámetros x y y indican la posición de mouse en coordenadas relativas dentro de la ventana cuando el botón del mouse fue presionado.
glutMotionFunc, glutPassiveMotionFunc

Uso

void glutMotionFunc(void (*func)(int x, int y));
void glutPassiveMotionFunc(void (*func)(int x, int y));
func.- la nueva función de movimiento o movimiento pasivo

Descripción

glutMotionFunc and glutPassiveMotionFunc dispone la función de movimiento o movimiento pasivo dentro de la ventana activa. La función de movimiento es accionada cuando mouse se mueve dentro de la ventana mientras uno o mas botones son presionados. La función de movimiento pasivo es llamada cuando el mouse se mueve dentro de la ventana mientras que no hay botones presionados. Los parámetros x y y indican la posición del mouse en la ventana en coordenadas relativas.

glutVisibilityFunc

Uso

void glutVisibilityFunc(void (*func)(int estado));
func.- la nueva función de visibilidad

Descripción

glutVisibilityFunc dispone la función de visibilidad dentro de la ventana actual. Esta función es llamada cuando la visibilidad en una ventana ha cambiado. El parámetro estado puede ser GLUT_NOT_VISIBLE o GLUT_VISIBLE dependiendo en la la visibilidad actual de la ventana. GLUT_VISIBLE no distingue entre una ventana totalmente visible a una parcialmente visible. GLUT_NOT_VISIBLE significa que ninguna parte de la ventana es visible. GLUT considera a una ventana visible si cualquier píxel de la ventana es visible o cualquier píxel de cualquier ventada descendiente es visible en la pantalla.

glutEntryFunc

Uso

void glutEntryFunc(void (*func)(int estado));
func.- la nueva función de entrada

Description

glutEntryFunc dispone la función de entrada/salida del mouse para la ventana actual. El parámetro estado es uno de los siguientes: GLUT_LEFT o GLUT_ENTERED , dependiendo si el puntero del mouse se ha ido o a entrado a la ventana. Algunos sistemas no generaran correctas llamadas a funciones de entrada y salida del mouse.

glutSpecialFunc

Uso

void glutSpecialFunc(void (*func)(int tecla, int x, int y));
func .- la nueva función de entrada

Description

glutSpecialFunc dispone la función para teclas especiales dentro de la ventana actual. Esta función es activada cuando las teclas de funciones o teclas de dirección son presionadas en el teclado. El parámetro tecla es una constante GLUT_KEY_* para la tecla especial presionada. Los parámetros x y y indican la posición de mouse en coordenadas relativas dentro de la ventana cuando la tecla fue presionada. Las teclas especiales son:

GLUT_KEY_F1
Tecla F1
GLUT_KEY_F2
Tecla F2
GLUT_KEY_F3
Tecla F3
GLUT_KEY_F4
Tecla F4
GLUT_KEY_F5
Tecla F5
GLUT_KEY_F6
Tecla F6
GLUT_KEY_F7
Tecla F7
GLUT_KEY_F8
Tecla F8
GLUT_KEY_F9
Tecla F9
GLUT_KEY_F10
Tecla F10
GLUT_KEY_F11
Tecla F11
GLUT_KEY_F12
Tecla F12.
GLUT_KEY_LEFT
Tecla de dirección izquierda
GLUT_KEY_UP
Tecla de dirección arriba
GLUT_KEY_RIGHT
Tecla de dirección derecha
GLUT_KEY_DOWN
Tecla de dirección abajo
GLUT_KEY_PAGE_UP
Tacla de avance de página.
GLUT_KEY_PAGE_DOWN
Tacla de retroceso de página
GLUT_KEY_HOME
Tecla de inicio
GLUT_KEY_END
Tecla de fin
GLUT_KEY_INSERT
Tecla de insertar

Note que las teclas de escape, suprimir y borrar generan un código ASCII , por lo tanto no son teclas especiales

glutSpaceballMotionFunc

Uso

void glutSpaceballMotionFunc(void (*func)(int x, int y, int z));
func .- la nueva entrada para la función

Descripción

glutSpaceballMotionFunc dispone la función dentro de la ventana actual para el Spaceball. Esta función es activada cuando la ventana tiene un foco de entrada del Spaceball (normalmente cuando el mouse esta dentro de la ventana) y el usuario genera una traslación del Spaceball. Los parámetros x, y y z indican la traslación en los ejes X, Y y Z respectivamente. Los parámetros se normalizan para estar dentro del rango de -1000 a 1000.

Nota: el Spaceball es un dispositivo de entrada con 6 grados de libertad

glutSpaceballRotateFunc

Uso

void glutSpaceballRotateFunc(void (*func)(int x, int y, int z));
func.- la nueva entrada para la función

Descripción

glutSpaceballRotateFunc dispone la función de rotación para el Spaceball dentro de la ventana actual. Esta Función es llamada cuando el foco de entrada del Spaceball (normalmente cuando el mouse esta dentro de la ventana) y el usuario genera una rotación en el spaceball. Los parámetros x, y y z indican la rotación dentro de los ejes X, Y y Z. los parámetros son normalizados para estar dentro del rango de –1800 a 1800.

Nota: el Spaceball es un dispositivo de entrada con 6 grados de libertad

7.12 glutSpaceballButtonFunc

Uso

void glutSpaceballButtonFunc(void (*func)(int botón, int estado));
func.- la nueva entrada para la función

Descripción

glutSpaceballButtonFunc dispone la función para los botones del Spaceball. Esta función es llamada cuando el foco de entrada del Spaceball (normalmente cuando el mouse esta dentro de la ventana) y el usuario presiona algún botón del Spaceball. El parámetro botón será el número del botón (empezando en uno). El número de botones disponibles puede ser determinado con glutDeviceGet(GLUT_NUM_SPACEBALL_BUTTO NS). El estado es GLUT_UP o GLUT_DOWN indicando si el botón esta siendo liberado o presionado respectivamente.

Nota: el Spaceball es un dispositivo de entrada con 6 grados de libertad

glutButtonBoxFunc

Uso

void glutButtonBoxFunc(void (*func)(int button, int state));

Descripción

glutButtonBoxFunc coloca el callback de botón de caja de marcado y botón para la ventana actual. El callback de botón de caja de marcado y botón para una ventana es llamado cuando la ventana tiene una entrada de caja de marcado y botón (normalmente, cuando el Mouse se encuentra dentro de la ventana) y el usuario genera entradas de presión de botón de caja de marcado y botón. El parámetro de botón será el número de botón (comenzando con uno). El número de botón de marcado y botón puede ser dterminado con glutDeviceGet (GLUT_NUM_BUTTON_BOX_BUTTONS). El estado es GLUT_UP o GLUT_DOWN, lo cual indica si el callback se debió a una presión o a una falta de tal, respectivamente. Func se refiere a la función callback a ejecutarse.

glutDialsFunc

Uso

void glutDialsFunc(void (*func)(int dial, int value));

Descripción

glutDialsFunc coloca el callback de la caja de marcado de botón y marcado para la ventana actual. El callback de la caja de marcado de botón y marcado para una ventana generalmente se efectúa cuando la ventana tiene una caja de marcado y botón con una entrada enfocada (normalmente, cuando el Mouse se encuentra dentro de la ventana) y el usuario genera cambios de caja de marcado de marcado y botón. El parámetro de marcado será el del número marcado (empezando por uno). El número de marcados de la caja de botón y marcado disponible puede ser determinado con glutDeviceGet (GLUT_NUM_DIALS). El valor mide la rotación absoluta en grados. Los valores de marcado no giran con cada rotación completa, mas continúan acumulando grados (hasta que haya un desbordamiento de int dial value). Func se refiere a la función callback a ejecutarse.

glutTabletMotionFunc

Uso

void glutTabletMotionFunc(void (*func)(int x, int y));

Descripción

glutTabletMotionFunc coloca el callback de moción de tableta para la ventana actual. El callback para la moción de tableta para una ventana se ejecuta cuando la ventana tiene un enfoque de entrada por tableta (cuando el Mouse está dentro de la ventana) y el usuario genera la moción de tableta. Los parámetros callback de x y y indican la posición absoluta del “puck” de la tableta en la tableta. Los parámetros de callback se normalizan en el rango de 0 a 2000 inclusivos. Func se refiere a la función callback a ejecutarse.

glutTabletButtonFunc

Uso

void glutTabletButtonFunc(void (*func)(int button, int state, int x, int y));

Descripción

glutTabletButtonFunc coloca el callback de botón de tableta para la ventana actual. El callback de botón de tableta es llamado cuando la ventana tiene un enfoque de entrada de tableta y el usuario genera entradas por presión de botón de tableta. El parámetro de botón será el número de botón (comenzando con uno). El número disponible de botones de tabletas puede ser determinado con glutDeviceGet (GLUT_NUM_TABLET_BUTTONS). El estado será GLUT_UP o GLUT_DOWN, indicando si el callback ocurre debido a una liberación o a una presión, respectivamente. Los parámetros de callback x y y indican las coordenadas relativas de la ventana cuando el botón de tableta es cambiado. Func se refiere a la función callback a ejecutarse.

glutMenuStatusFunc

Uso

void glutMenuStatusFunc(void (*func)(int status, int x, int y)); ó void glutMenuStateFunc(void (*func)(int status));

Descripción

glutMenuStatusFunc coloca el callback del estado del menú global para que un programa GLUT pueda determinar cuando un menú está en uso o no. Cuando el callback del estado de un menú es registrado, será llamado con el valor de GLUT_MENU_IN_USE por su parámetro de valor cuando los menús pop-up estén siendo usados por el usuario; y el callback entonces será llamado con el valor GLUT_MENU_NOT_IN_USE por su parámetro de estado cuando los menús pop-up no estén siendo usados. Los parámetros x y y indican la localización en coordenadas de ventana de la presión de botón que causó que el menú estuviera en uso o la localización donde el menú fue liberado (puede ser fuera de la ventana). El parámetro fun. Nombra la función callback. Otros callbacks continúan operando (excepto por los callbacks de movimiento del Mouse) cuando los menús pop-up están en uso para que los callback de estado de menú permitan a un programa suspender su animación u otras tareas cuando los menús están en uso. Los menús de unmapping o de cascada de un menú pop-up inicial no generan llamadas al estado de menú. Hay un solo callback de estado de menú para GLUT.

glutMenuStateFunc es una función simplificada de la anterior: esta no recibe parámetros de coordenadas x y y.

glutIdleFunc

Uso

void glutIdleFunc(void (*func)(void));

Descripción

glutIdleFunc coloca el callback de inactividad global para ser func para que así un programa GLUT pueda realizar procesos continuos de animación cuando el los eventos de sistema de ventana no estén siendo recibidos. Si se habilita, el callback de inactividad se llama continuamente cuando no haya eventos recibidos. La rutina de callback no tiene parámetros. La ventana actual y el menú actual no serán cambiados antes del callback de inactividad. Los programas con ventanas o menús múltiples deben colocar explícitamente la ventana y/o el menú actual y no deberán confiar en su configuración actual.

glutTimerFunc

Uso

void glutTimerFunc(unsigned int msecs, void (*func)(int value), value)

Descripción

glutTimerFunc registra la func de callback de tiempo para que sea ejecutada en al menos msecs milisegundos. El parámetro value para el callback de tiempo será el valor del parámetro value para glutTimerFunc. Callbacks múltiples de tiempo al mismo tiempo o en diferentes tiempos pueden ser registradas simultáneamente.

glutSetColor

Uso

void glutSetColor(int cell, GLfloat red, GLfloat green, GLfloat blue);

Descripción

Coloca el mapa de colores del índice de color de cell para el mapa de color lógico para la ventana actual para la capa en uso con el color especificado por red, green y blue (rojo, verde y azul, cuyos rangos varían desde 0.0 hasta 1.0). La capa en uso para la ventana actual debe ser una ventana de índice de color. Cell debe ser cero o más grande y menos del número total de entradas de mapa de color para la ventana. Si el mapa de color de la capa en uso fue copiado por una referencia, una llamada a glutSetColor forzará la duplicación del mapa de colores.

glutGetColor

Uso

GLfloat glutGetColor(int cell, int component);

Descripción

glutGetColor obtiene los components rojo, verde o azul para una entrada de mapa de colores de índice de colores dada para el color de mapa lógico de la ventana. La ventana actual debe ser una ventana de índice de color. Cell debe ser cero o mayor y menor del número de total de entradas de mapa de color para la ventana. Para índices de color válidos, el valor regresado es un valor de punto flotante entre 0.0 y 1.0. glutGetColor devolverá .0 si el índice de color especificado es un índice transparente de overlay, menos de cero o mayor o igual al valor devuelto por glutGet (GLUT_WINDOW_COLORMAP_SIZE), esto es si el índice de color es transparente o está fuera del rango de los índices de color válidos.

glutCopyColormap

Uso

void glutCopyColormap(int win);

Descripción

glutCopyColormap copia (lentamente de ser posible, para promover el compartir archivos) el mapa de color lógico de una ventana especificada a la capa en uso de la ventana. La copia será del plano normal al plano normal; o del overlay al overlay (nunca a través de capas distintas). Una vez que el mapa de color haya sido copiado, evite colocar cells en el mapa de color con glutSetColor, ya que eso forzará una copia actual del mapa de colores si fue copiada previamente por referencia. glutCopyColormap solamente debería ser empleada cuando ambas la ventana actual y la ventana win sean ventanas de índice de color.

glutGet

Uso

int glutGet(GLenum state);

Descripción

glutGet obtiene un estado simple de GLUT representado por enteros. El parámetro state determina qué tipo de estado regresará. El estado de capacidad de la ventana se regresa para la capa en uso. Nombres de estado de GLUT comenzando por GLUT_WINDOW_ devuelven el estado para la ventana actual. Nombres de estado de GLUT comenzando por GLUT_MENU_ devuelven el estado para el menú actual. Otros nombres de estado de GLUT devuelven un estado global. El pedir un estado para un nombre de estado inválido de GLUT devuelve un uno negativo.

glutLayerGet

Uso

int glutLayerGet(GLenum info);

Descripción

glutLayerGet obtiene la información de la capa GLUT para la ventana actual representada por enteros. El parámetro info determina qué tipo de información de capa hay que devolver.

glutDeviceGet

Uso

int glutDeviceGet(GLenum info);

Descripción

glutDeviceGet obtiene información de dispositivos GLUT representados por enteros. El parámetro info determina qué tipo de información de dispositivo hay que devolver. El pedir la información de dispositivo para una información de dispositivo GLUT inválida devuelve un uno negativo.

glutGetModifiers

Uso

int glutGetModifiers(void);

Descripción

glutGetModifiers devuelve el estado de las teclas modificadoras al momento en el cual un evento de entrada para el teclado, especial o Mouse se genera. Esta rutina sólo puede ser llamada mientras se maneja el teclado, especial o el Mouse. Al sistema de ventana le es permitido interceptar teclas modificadoras definidas para el sistema de ventana o botones de Mouse, en cuyo caso, no se generará ningún callback GLUT. Esta intercepción es independiente al uso de glutGetModifiers.

glutExtensionSupported

Uso

int glutExtensionSupported(char *extension);

Descripción

glutExtensionSupported ayuda a determinar fácilmente si una extensión de OpenGL dada está soportada o no. El parámetro extensión da nombre al query de extensión. Las extensiones soportadas tambien pueden ser determinadas con glGetString (GL_EXTENSIONS), pero glutExtensionSupported reconoce el parking correcto de la cadena devuelta.

glutExtensionSupported devuelve un no-cero si la extensión es soportada y cero si no lo es.

Debe haber una ventana actual válida para llamar a glutExtensionSupported.
glutExtensionSupported sólo devuelve información de extensiones soportadas por OpenGLO. Esto significa que los sistemas de ventana dependientes de extensiones (por ejemplo, extensiones GLX) no se reportan en glutExtensionSupported.

glutBitmapCharacter

Uso

void glutBitmapCharacter(void *font, int character);
font .- Tipo de Fuente para el caracter que se va a utilizar
carácter.- Caracter a renderizar.

Descripción

Renderiza un caracter usando OpenGL. Permite mostrar en la pantalla un caracter con algún tipo de fuente que se le asigne.

Las Fuentes disponibles para glutBitmapCharacter son:

GLUT_BITMAP_8_BY_13
-misc-fixed-medium-r-normal--13-120-75-75-C-80-iso8859-1
GLUT_BITMAP_9_BY_15
-misc-fixed-medium-r-normal--15-140-75-75-C-90-iso8859-1
GLUT_BITMAP_TIMES_ROMAN_10
-adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1
GLUT_BITMAP_TIMES_ROMAN_24
-adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1
GLUT_BITMAP_HELVETICA_10
-adobe-helvetica-medium-r-normal--10-100-75-75-p-56-iso8859-1
GLUT_BITMAP_HELVETICA_12
-adobe-helvetica-medium-r-normal--12-120-75-75-p-67-iso8859-1
GLUT_BITMAP_HELVETICA_18
-adobe-helvetica-medium-r-normal--18-180-75-75-p-98-iso8859-1

La representación de un carácter que no existe no tiene ningún efecto.


glutBitmapWidth

Uso

int glutBitmapWidth(GLUTbitmapFont font, int character)
font.- Tipo de Fuente para el caracter que se va a utilizar
caracter.- Carácter a devolver el ancho.

Descripción

Devuelve el valor del ancho de un carácter en píxeles.

Mientras que el ancho de los caracteres en una fuente puede variar, las características de la altura máxima de una fuente en particular son fijas.


glutStrokeCharacter

Uso

void glutStrokeCharacter(void *font, int character);
font.- Fuente a utilizar
character.- Caracter a renderizar.

Descripción

Renderiza un Stroke Caracter(Caracter de tipo a mano alzada). Las Fuentes disponibles para esta función son las siguientes:

GLUT_STROKE_ROMAN
Roman Simple Espaciada Proporcionadamente. El máximo alto de los caracteres en esta fuente es de 119.05 unidades.
GLUT_STROKE_MONO_ROMAN
Roman Simple monoespaciada. El máximo alto de los caracteres en esta fuente es de 119.05 unidades. Cada caracter es de 104.76 unidades de ancho.

glutStrokeWidth

Uso

int glutStrokeWidth(GLUTstrokeFont font, int character)
font.- Fuente a utilizar
character.- Caracter a devolver el ancho.

Descripción:

Devuelve el valor de el ancho de un Stroke caracter en píxeles.

Mientras que el ancho de los caracteres en una fuente puede variar, las características de la altura máxima de una fuente en particular son fijas.


glutSolidSphere, glutWireSphere

Uso

void glutSolidSphere(GLdouble radius, GLint slices, GLint stacks);
void glutWireSphere(GLdouble radius, GLint slices, GLint stacks);
radius.- Radio de la esfera
slices .-Numero de subdivisions alrededor del eje Z(similar a líneas de longitud)
stacks .-Numero de subdivisions a lo largo del eje Z(similar a líneas de latitud)

Descripción

Renderiza una esfera sólida o de tipo de conexiones de líneas respectivamente.

glutSolidCube, glutWireCube
Renderiza un cubo sólido (glutSolidCube) o de tipo de conexiones de líneas (glutWireCube) respectivamente.
void glutSolidCube(GLdouble size);
void glutWireCube(GLdouble size);

El cubo es centrado el origen de los coordenadas del modelado con los lados del tamaño de la longitud.


glutSolidCone, glutWireCone

Uso

void glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
void glutWireCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
base.- El radio de la base del cono
height.- El alto del cono
slices.- Número de subdivisiones alrededor del eje Z
stacks.- Número de subdivisions a lo largo del eje Z

Descripción

Renderiza un cono sólido (glutSolidCone) o de tipo de conexiones de líneas(glutWireCone) respectivamente.

glutSolidTorus, glutWireTorus

Uso

void glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius,
GLint nsides, GLint rings);
void glutWireTorus(GLdouble innerRadius, GLdouble outerRadius,
GLint nsides, GLint rings);
innerRadius.- Radio interno de la dona.
outerRadius.- Radio Externo de la dona
insides.- Numero de lados por cada sección radial
rings.- Número de divisiones radiales para la dona

Descripción

Renderiza una dona sólida (glutSolidTorus) o de tipo de conexiones de líneas (glutWireTorus) respectivamente.

La dona es centrada el origen de los coordenadas del modelado cuyos ejes son alineados con el eje Z.

glutSolidDodecahedron, glutWireDodecahedron

Uso

void glutSolidDodecahedron(void);
void glutWireDodecahedron(void);

Descripción

Renderiza un dodecaedro(doce lados) sólido ( glutSolidDodecahedron) o de tipo de conexiones de líneas (glutWireDodecahedron) respectivamente
La imagen es centrada en el origen de las coordenadas del modelo con un radio de raíz de 3.

glutSolidOctahedron, glutWireOctahedron

Uso

void glutSolidOctahedron(void);
void glutWireOctahedron(void);

Descripción

Renderiza un octaedro(ocho lados) sólido ( glutSolidOctahedron) o de tipo de conexiones de líneas (glutWireDoOctahedron) respectivamente.
La imagen es centrada en el origen de las coordenadas del modelo con un radio de 1.

glutSolidTetrahedron, glutWireTetrahedron

Uso

void glutSolidTetrahedron(void);
void glutWireTetrahedron(void);

Descripción

Renderiza un tetraedro(cuatro lados) sólido ( glutSolidTetrahedron) o de tipo de conexiones de líneas (glutWireTetrahedron) respectivamente.
La imagen es centrada en el origen de las coordenadas del modelo con un radio de raíz de tres.

glutSolidIcosahedron, glutWireIcosahedron

Uso

void glutSolidIcosahedron(void);
void glutWireIcosahedron(void);

Descripción

Renderiza un icosaedro(veinte lados) sólido ( glutSolidIcosahedron) o de tipo de conexiones de líneas (glutWireDoIcosahedron) respectivamente.
La imagen es centrada en el origen de las coordenadas del modelo con un radio de 1.
glutSolidTeapot, glutWireTeapot

Uso
.
void glutSolidTeapot(GLdouble size);
void glutWireTeapot(GLdouble size);
size.- Tamaño relativo de la Tetera

Descripción

Renderiza una figura en forma de tetera ya sea sólida (glutSolidTeapot) o de tipo de conexiones de líneas(glutWireTeapot
Tanto las coordenadas de la superficie normal como la textura son generadas. La tetera se genera con los evaluadores de OpenGL.

Programas

programa del nombre con bitmap

/*progrma que despliega mi nombre y con los botones del mouse se cambiara de tamaño
Existen dos tamaños de letras debido a las complicaciones de la función glutBitMapCharacter*/
#include
#include
/*Fuentes a ser desplegadas*/
void *font = GLUT_BITMAP_HELVETICA_18 ;
void *fonts[] =
{
GLUT_BITMAP_HELVETICA_10,
GLUT_BITMAP_HELVETICA_18
};
/*esta función es para desplegar el texto, letra por letra*/
void despliegue(int x, int y, char *nombre)
{
int longitud, i;
glRasterPos2f(x, y);
longitud = (int) strlen(nombre);
for (i = 0; i < longitud; i++)
{
glutBitmapCharacter(font, nombre[i]);
}
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
despliegue(135, 100, "Adrian Pablo Araya Valenzuela");
glutSwapBuffers();
}
void mouse(int button, int state, int x, int y)
{
if (button == GLUT_LEFT_BUTTON)
{
font = GLUT_BITMAP_HELVETICA_10;
glutPostRedisplay();
}
else if (button == GLUT_RIGHT_BUTTON)
{
font = GLUT_BITMAP_HELVETICA_18;
glutPostRedisplay();
}
}
void reshape(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, w, h, 0);
glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char **argv)
{
glutInitDisplayMode(GLUT_DOUBLE GLUT_RGB);
glutInitWindowSize(500, 200);
glutInitWindowPosition (150, 150);
glutCreateWindow(argv[0]);
glClearColor(0.0, 0.0, 0.0, 1.0);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMainLoop();
return 0;
}

programa del nombre con stroke

/*Progrma que despliega mi nombre con glutStrokeCharacter, con los botones del mouse
el nombre se hara mas chico o mas grande*/
#include
#include
#include
#include
/*Escala*/
static float escala = 0.002;
/*Funcion para desplegar el nombre con la funcion glutStrokeCharacter.*/
void despliegue(GLfloat x, GLfloat y, char *nombre)
{
va_list args;
char nombrebuff[200], *apuntanombre;
va_start(args, nombre);
vsprintf(nombrebuff, nombre, args);
va_end(args);
glPushMatrix();
glTranslatef(x, y, 0);
glScalef((GLfloat)escala, (GLfloat)escala, (GLfloat)escala);
for (apuntanombre = nombrebuff; *apuntanombre; apuntanombre++)
{
glutStrokeCharacter(GLUT_STROKE_MONO_ROMAN , *apuntanombre);
}
glPopMatrix();
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluPerspective(40.0, 1.0, 0.1, 20.0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
gluLookAt(0.0, 0.0, 8.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.);
glPushMatrix();
glTranslatef(0, 0, -2);
despliegue(-3.0, 0, "Adrian Pablo Araya Valenzuela");
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glFlush();
}
void mouse(int button, int state, int x, int y)
{
if (state == GLUT_DOWN)
{
if (button == GLUT_LEFT_BUTTON)
{
escala = escala - 0.00005;
glutPostRedisplay();
}
else if (button == GLUT_RIGHT_BUTTON)
{
escala = escala + 0.00005;
glutPostRedisplay();
}
}
}
void reshape(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, w, 0, h);
glScalef(1, -1, 1);
glTranslatef(0, -h, 0);
glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE GLUT_RGB);
glutInitWindowSize(800, 350);
glutInitWindowPosition (150, 150);
glutCreateWindow(argv[0]);
glClearColor(0.0, 0.0, 0.0, 1.0);
glColor3f(1, 1, 1);
glLineWidth(2.0);
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

Reloj

/*progrma que despliega un conometro y con los botones del mouse se reseteara el cronometro o
se para la cuenta*/
#include
#include
static int segundos = 0;
static int minutos = 0;
static int horas = 0;
static char segcad[2];
static char mincad[2];
static char horcad[2];
static int prueba = 1;
/*Fuentes a ser desplegadas*/
void *font = GLUT_BITMAP_HELVETICA_18 ;
void *fonts[] =
{
GLUT_BITMAP_HELVETICA_10,
GLUT_BITMAP_HELVETICA_18
};
/*esta función es para desplegar el texto, letra por letra*/
void despliegue(int x, int y, char *cadena)
{
int longitud, i;
glRasterPos2f(x, y);
longitud = (int) strlen(cadena);
for (i = 0; i < longitud; i++)
{
glutBitmapCharacter(font, cadena[i]);
}
}
void cronometro(void)
{
if (prueba == 1)
{
segundos = segundos + 1;
glutPostRedisplay();
if (segundos == 60)
{
segundos = 0;
minutos = minutos + 1;
glutPostRedisplay();
if (minutos == 60)
{
minutos = 0;
horas = horas + 1;
glutPostRedisplay();
if (horas == 24)
{
horas = 0;
glutPostRedisplay();
}
}
}
glutTimerFunc(1000, cronometro,1);
}
else
{
}
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
if (horas < 10)
{
despliegue(135,100,"0");
itoa(horas, horcad, 10);
despliegue(145,100,horcad);
}
else
{
itoa(horas, horcad, 10);
despliegue(135,100,horcad);
}
despliegue(155,100,":");
if (minutos < 10)
{
despliegue(160,100,"0");
itoa(minutos, mincad, 10);
despliegue(170,100,mincad);
}
else
{
itoa(minutos, mincad, 10);
despliegue(160,100,mincad);
}
despliegue(180,100,":");
if (segundos < 10)
{
despliegue(185,100,"0");
itoa(segundos, segcad, 10);
despliegue(195,100,segcad);
}
else
{
itoa(segundos, segcad, 10);
despliegue(185,100,segcad);
}
glutSwapBuffers();
}
void mouse(int button, int state, int x, int y)
{
if (state == GLUT_DOWN)
{
if (button == GLUT_LEFT_BUTTON)
{
segundos = 0;
minutos = 0;
horas = 0;
glutPostRedisplay();
}
else if (button == GLUT_RIGHT_BUTTON)
{
if(prueba == 1)
{
prueba = 0;
glutPostRedisplay();
}
else
{
prueba = 1;
glutPostRedisplay();
glutTimerFunc(1000, cronometro,1);
}
}
}
}
void reshape(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, w, h, 0);
glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char **argv)
{
glutInitDisplayMode(GLUT_DOUBLE GLUT_RGB);
glutInitWindowSize(500, 200);
glutInitWindowPosition (150, 150);
glutCreateWindow(argv[0]);
glClearColor(0.0, 0.0, 0.0, 1.0);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutTimerFunc(1000, cronometro, 1);
glutMainLoop();
return 0;
}

Tarea 4

Rectas: algoritmo de Bresenham

1. El objetivo es minimizar el error usando aritmética entera
2. Recta de (x1, y1) a (xN, yN) , coordenadas enteras
3. Supongamos x1 < id="BLOGGER_PHOTO_ID_5051186099425482626" style="CURSOR: hand" alt="" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhGSbrUxWEbf0HWy8nuJgLkJvSasmw6iwDjwWhlE2LKPCGy7bAWU9Tl3PEvCs-ejysrxdjEoWwQtGhU0h_jKOdGVA0Qnd5EOeEuCBrbvWVN3U_aOecsTRhVi-CfDgxYPLjg_sjOUsqa1p8E/s320/Dibujo1.JPG" border="0">
4. Cálculo de y2:
Búsqueda de alternativa de menor error

5. Como m es un número en coma flotante, se usa como parámetro de decisión:

6. Cálculo de yi+1:

7. Fórmula iterativa para pi:

8.Algoritmo:
a)Si Dy > Dx, intercambiar los papeles de y y de x (x <=> y)
b)Si Dx <>(xN,yN))
c)Si Dy < 0, decrementar la y (y i+1 = yi - 1) y tomar Dy como positivo en el algoritmo
d)p1 = 2 Dy - Dx 5.Bucle hasta llegar a (xN, yN):
e)Bucle hasta llegar a (xN, yN):

9.Nota
a)La x del algoritmo es la coordenada de barrido (que puede ser la y por el punto 1.).
b)La y del algoritmo es la coordenada calculada (que puede ser la x por el punto 1.).
c)Dx y Dyson siempre positivos en el algoritmo y se corresponden con los incrementos de las coordenadas de barrido y calculada, respectivamente. Precálculo de constantes
10.Precálculo de constantes

Fuentes

http://www.ii.uam.es/~pedro/graficos/teoria/Primitivas/Primitivas.htm#RectaBresenham

Practica 5

Esta práctica fue meramente demostrativa, nos enfocamos a ver algunos coman dos los cuales pueden emplearse para dar diferentes efectos a nuestros códigos en OpenGL.

Primero vimos la importancia de tener activados dos buffers, en algunos programas las imágenes se ven como con un efecto de parpadeo, esto es porque el buffer de video no logra tener la información necesaria en el tiempo requerido y al desplegarla aparece con errores o falta de imagen, si tenemos un segundo buffer de video el primero despliega la información mientras que el segundo es llenado con el siguiente cuadro, cuando se desplegó totalmente el primer buffer este se limpia para ser llenado con el cuadro siguiente y el segundo buffer entra en acción desplegando su información, con esto se logra tener una fluidez mejor en las imágenes. Para tener una buena animación debe tener por lo menos 24 cuadros por segundo.

Además vimos varias instrucciones y parámetros. Para la función glutInitDisplayMode (); vimos los parámetros GLUT_RGB el cual define los colores en sus tres bases rojo, verde y azul, GLUT_DEPTH la cual se refiere a la profundidad (z buffer), GLUT_SINGLE el cual solo reservara un espacio en memoria para un frame buffer y GLUT_DOUBLE el cual reservara dos espacios de memoria, teniendo asi dos frame buffers. Además vimos la funcion glClear(); la cual limpia el buffer, glFlush (); vacía el contenido que se encuentra en el frame buffer y el glutSwapBuffer(); el cual hace el intercambio entre los dos frame buffers. Además para poder hacer un display cuando nosotros queramos y no esperarnos hasta que él programa regrese a su función normal de display usaremos el glutPostRedisplay();.

Después de esto vimos como interactuar con los diferentes dispositivos de entrada, como e teclado el cual será utilizado mediante la función glutKeyboardFunc(keyboard); la cual llama a la función keyboard , void keyboard (unsigned char key, int x, int y), donde char es el valor ASCII del carácter presionado y los parámetros x y y serán la posición del mouse en el momento que la tecla fue presionada, existen muchas mas funciones las cuales contemplan, desplazamiento del mouse, apretar los botones del mouse y teclas especiales del teclado como las flechas de dirección. Todo esto se vera con mas detalle en otras prácticas.