Ka Falla O Falta En Estos Tutoriales De Opengl

Taris · 24 de Agosto de 2005, 09:06:08 PM

Tengo dos tutoriales hechos. El primero se trata de hacer una ventan con un cuadrado y que si escalamos la ventana el cuadrado continuara siendo cuadrado y al mismo tiempo se escalara. Lo que passa es que no hace exactamente eso (programo en dev), cuando escalo o se hace muy grande o desaparece. En teoria el codigo tiene k estar bien pero no se k puede pasar.

1r tuto codigo:
#include "gl/glut.h"

void Renderescena(void)
{
//Esta funcion borra un bufer determinado o conjunto de estos.
//En opengl encontramos varios tipos de bufer (color, profundidad, plantillas y acumulacion)
//En este caso borramos el bufer de color que es donde se encuentra la imagen guardada internamente y con esta funcion
//borramos el ultimo dibujo de la ventana.
glClear(GL_COLOR_BUFFER_BIT);
//Establecer un color para dibujar, en este caso el rojo. Los parametros son RGB.
glColor3f(1.0f,0.0f,0.0f);
/*Dibujar el rectangulo relleno con el color de dibujo. Los parametros pasados son coordenadas de puntos en diagonal
(x1,y1)(x2,y2) En realidad lo que le decimos al ordenador es dibujar un diagonal desde el punte superior izquierdo
hasta el punto inferior derecho*/
glRectf(-25.0f,25.0f,25.0f,-25.0f);
//ejecuta todos los comandos de opengl que no se hayan ejecutado ya.
glFlush();
}

void SetupRC(void)
{
//Establece el color de borrado de la pantalla(pero no la borra), en este caso ventana.
//los parametros son rojo,verde,azul,alpha son de tipos float.
glClearColor(0.0f,0.0f,1.0f,1.0f);

}
/*Opengl tiene sus propias variables, como por ejemplo esta: Glsizei es una variable numero entero de 32 bits.
He puesto de nombre W y H anchura y altura en ingles width y height.*/
//Esta funcion recibe la anchura y la altura siempre que canvia el tamaño de la ventana. Luego manipulamos la informacion.
void ChangeTamano (GLsizei w, GLsizei h)
{
//Variable de opengl numero de coma flotante de 32 bits.
GLfloat aspectRatio;
//Para evitar la division entre 0.
if(h==0)
{
h=1;
//primero llamamos a esta funcion pasandole los parametros nuevos de anchura y altura (w,h).
/*lo parametros de esta funcion son esquina inferior izquierda del puerto de vista, no de la ventana, coordenadas X e Y
, los otros dos son anchura y altura del puerto de vista Width y height.
Un puerto de vista defian el area donde dentro de la ventana donde opengl puede dibujar*/
glViewport(0,0,w,h);
/*Establecemos el sistema de coordenadas. Aunque estemos dibujando en 2D pensar que estamos en un sistema de dibujo de 3D
por eso lo que hacemos es dejar el valor de la coordenada z en 0 y decirle al opengl que utilizamos una projeccion*/
glMatrixMode(GL_PROJECTION);
/*Reestablece el sistema de coordenadas antes de qualquier operacion de matriz, como por ejemplo glOrtho*/
glLoadIdentity();
}
//Establecer el volumen de recorte (izquierda,derecha, superior, inferior, cerca, lejos).
//Nuestro volumen de recorte es el espacio de coordenadas visible.
//aspectRatio o ratio de aspecto es una relacion de un numero de pixels sobre una longitud horizontal.
aspectRatio=(GLfloat)w / (GLfloat)h;
if(w<=h)
{
/*Esta funcion modifica el volumen de recorte existente, los parametros son (izquierda, derecha, inferior, superior, cerca,
lejos). Multiplica de la matriz que describe el area de recorte actual
por la que describimos en sus parametros.*/
glOrtho(-100.0, 100.0, -100.0 / aspectRatio, 100.0 / aspectRatio, 1.0, -1.0);

}
else
{
glOrtho( -100.0 * aspectRatio, 100.0 * aspectRatio, -100.0, 100.0, 1.0, -1.0);

//esto indica que todas las transformaciones futuras afectaran a nuestro modelo.
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}//gracias a este if mantenemos el "cuadrado" cuadrado.
}
main(void)
{
//Para establecer el modo del bufer. El bufer es donde se guardan los comandos de dibujo en este caso al ser simple
//todos estos comandos se ejecutan en el dibujo de la ventana.
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
//Crea la ventana y pone como titulo de esta simple.
glutCreateWindow("Caudrado");

//llama a la funcion que se encarga del borrado de pantalla o del bufer para ser mas exactos. Y luego dibuja la escena.
//Bufer es una zona de almacenamiento de datos de la imagen. Los componentes de colo o de dibujo se conocen como:
//bufer de color o bufer de pixeles.
glutDisplayFunc(Renderescena);
/*Detecta y controla los canvios en el tamaño en la ventana mediante otra funcion que nos devuelve el tamaño
de la ventana (anchura y altura) para ello hemos creado la funcion que se llama ChangeTamaño (pondremos tamaño sin eñe
para que no nos de problemas, que podria pasar)*/
glutReshapeFunc(ChangeTamano);
//esta funcion realiza cualquier inicializacion que deberiamos hacer de opengl antes de la presentacion.
SetupRC();

//Inicia la ejecucion de la estructura principal de la libreria glut y libera todas la s funciones de llamada y a glut.
glutMainLoop();

}

El segundo tutorial se trata de reutilizar el codigo pero esta vez el cuadrado tiene k ir rebotando por los laterales de la pantalla pero si lo hace yo no lo veo. Creo que como ya falla el tutorial anterior y aprobecho casi todo el codigo tb falla este haber k me decis.

2tuto codigo:

#include "gl/glut.h"
///////////////////////////////////////////
////// Variables ///////
///////////////////////////////////////////

//posicion y tamaño iniciales de la figura
GLfloat x1=0.0f;
GLfloat y1=0.0f;
GLfloat tamano=25;
//valores para intervenir en el movimiento del cuadrado. Numero de pixeles a mover cada vez.
GLfloat xpaso=1.0f; //esto quiere decir que se movera un pixel cada vez.
GLfloat ypaso=1.0f;
//registrar o guardar los canvios de anchura y altura en las ventanas.
GLfloat windowWidth;
GLfloat windowHeight;

/////////////////
/// Funciones ///
/////////////////

void SetupRC(void)
{
//Establece el color de borrado de la pantalla(pero no la borra), en este caso ventana.
//los parametros son rojo,verde,azul,alpha son de tipos float.
glClearColor(0.0f,0.0f,1.0f,1.0f);
}
void RenderEscena(void)
{
//limpiar bufer
glClear(GL_COLOR_BUFFER_BIT);
//Seleccion del color para dibujar
glColor3f(1.0f,0.0f,0.0f);
//dibujar una figura rectangular con el color seleccionado.
glRectf(x1, y1, x1+tamano, y1-tamano);
/*Esta funcion limpia los comandos e intercanvios de dibujo al utilizar doble buffer como en este caso.
Si utilizaramos esta funcion con un unico buffer la animacion del cuadrado parpadearia. Cuando se utiliza doble buffer
implicitamente ya se hacer un borrado, por eso no necesitamos utilizar la funcion glFluxh() para ejecutar los comandos de
el buffer actual, porque lo k hacemos es un intercambio.*/
glutSwapBuffers();
}
void ChangeTamano(GLsizei w, GLsizei h)
{
//Variable del ratio de aspecto
GLfloat aspectRatio;
//control de division por 0
if(h==0)
{
h=1;
//posicion del area de recorte, anchura y altura. (x,y,anchura,altura).
glViewport(0, 0, w, h);
//Sistema de coordenadas.
glMatrixMode(GL_PROJECTION);
//Reestablecer el sistema de coordenada antes de cualquier operacion.
glLoadIdentity();
//establecer volumen de recorte
aspectRatio=(GLfloat)w / (GLfloat)h;
if(w<=h)
{
windowWidth=100;
windowHeight=100 / aspectRatio;
glOrtho(-100.0, 100.0, -windowHeight, windowHeight, 1.0, -1.0);
}
else
{
windowWidth=100 * aspectRatio;
windowHeight=100;
glOrtho(-windowWidth, windowWidth, -100.0, 100.0, 1.0, -1.0);
}
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

}
void TimerFunction(int valor)
{
//invertir la direccion de la figura en el caso que alcance el borde derecho o izquierdo
if(x1 > windowWidth-tamano || x1 < -windowWidth)
{

xpaso=-xpaso;
}
//invertir la direccion de la figura en el caso que alcance el borde inferior o superior
if(y1 > windowHeight || y1 < -windowHeight + tamano)
{
ypaso=-ypaso;
}
//mover la figura
x1+=xpaso;
y1+=ypaso;
/*comprovar los limites cuando la ventan se reduzca y mientras la figura este rebotando y este se encuentre
de repente fuera del area de recorte*/
if(x1 > (windowWidth - tamano + xpaso))
{
x1=windowWidth - tamano - 1;
}
else if(x1 < -(windowWidth + xpaso) )
{
x1=-windowWidth - 1;
}
if(y1 < -(windowHeight - tamano + ypaso))
{
y1=windowHeight - tamano - 1;
}
else if(y1 > (windowHeight + ypaso) )
{
y1=-windowHeight - 1;
}
//volver a dibujar la figura con las nuevas coordenadas.
glutPostRedisplay();
glutTimerFunc(3300, TimerFunction, 1);
}
/////////////////
/// Principal ///
/////////////////

main(void)
{
//Iniciamos el tipo de bufer esta vez sera doble.
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
//Creamos ventana.
glutCreateWindow("DobleBufer y animacion");
//Llamamos a la funcion de dibujo.
glutDisplayFunc(RenderEscena);
//Llamamos a la funcion de control de dimensiones de la ventana
glutReshapeFunc(ChangeTamano);
// Llamamos a la funcion que establece la cantidad de tiempo para llamar a otra funcion en este caso la de movimiento.
/*los parametros son (msec "milesimas de segundo que se debe esperar antes de ejecutar la funcion,
nombre de la funcion k llamamos, valor entero especificado por el usuario que le pasamos a la funcion) */
glutTimerFunc(33, TimerFunction, 1);
//Funcion de incializacion antes de la presentacion.
SetupRC();
glutMainLoop();
}

Pogacha · 24 de Agosto de 2005, 09:16:28 PM

Para empezar, si estas a tiempo de editar, editá y encerralos en [ CODE ] [ /CODE ] por que no se entiende nada ...
Despues lo miro mas detenidamente.
Saludos.

Taris · 24 de Agosto de 2005, 09:25:39 PM

copio el codigo y le doy al boton de code ok ese es el segundo

Código [Seleccionar]

#include "gl/glut.h"
///////////////////////////////////////////
//////         Variables            ///////
///////////////////////////////////////////  
    
//posicion y tamaño iniciales de la figura
GLfloat x1=0.0f;
GLfloat y1=0.0f;
GLfloat tamano=25;
//valores para intervenir en el movimiento del cuadrado. Numero de pixeles a mover cada vez.
GLfloat xpaso=1.0f; //esto quiere decir que se movera un pixel cada vez. 
GLfloat ypaso=1.0f;
//registrar o guardar los canvios de anchura y altura en las ventanas.
GLfloat windowWidth;
GLfloat windowHeight;

/////////////////
/// Funciones ///
/////////////////

void SetupRC(void)
{
     //Establece el color de borrado de la pantalla(pero no la borra), en este caso ventana.
     //los parametros son rojo,verde,azul,alpha son de tipos float.
     glClearColor(0.0f,0.0f,1.0f,1.0f);    
}
void RenderEscena(void)
{
    //limpiar bufer
    glClear(GL_COLOR_BUFFER_BIT);
    //Seleccion del color para dibujar
    glColor3f(1.0f,0.0f,0.0f);
    //dibujar una figura rectangular con el color seleccionado.
    glRectf(x1, y1, x1+tamano, y1-tamano);
    /*Esta funcion limpia los comandos e intercanvios de dibujo al utilizar doble buffer como en este caso.
    Si utilizaramos esta funcion con un unico buffer la animacion del cuadrado parpadearia. Cuando se utiliza doble buffer
    implicitamente ya se hacer un borrado, por eso no necesitamos utilizar la funcion glFluxh() para ejecutar los comandos de
    el buffer actual, porque lo k hacemos es un intercambio.*/
    glutSwapBuffers();
}
void ChangeTamano(GLsizei w, GLsizei h)
{
    //Variable del ratio de aspecto
    GLfloat aspectRatio;
    //control de division por 0
    if(h==0)
    {
        h=1;
        //posicion del area de recorte, anchura y altura. (x,y,anchura,altura).
        glViewport(0, 0, w, h);
        //Sistema de coordenadas.
        glMatrixMode(GL_PROJECTION);
        //Reestablecer el sistema de coordenada antes de cualquier operacion.
        glLoadIdentity();
        //establecer volumen de recorte
        aspectRatio=(GLfloat)w / (GLfloat)h;
        if(w<=h)
        {
            windowWidth=100;
            windowHeight=100 / aspectRatio;
            glOrtho(-100.0, 100.0, -windowHeight, windowHeight, 1.0, -1.0);
        }
        else
        {
            windowWidth=100 * aspectRatio;
            windowHeight=100;
            glOrtho(-windowWidth, windowWidth, -100.0, 100.0, 1.0, -1.0); 
        }
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
    }
    
}
void TimerFunction(int valor)
{
    //invertir la direccion de la figura en el caso que alcance el borde derecho o izquierdo
    if(x1 > windowWidth-tamano || x1 < -windowWidth)
    {
        
        xpaso=-xpaso;
    }
    //invertir la direccion de la figura en el caso que alcance el borde inferior o superior
    if(y1 > windowHeight || y1 < -windowHeight + tamano)
    {
        ypaso=-ypaso;
    }
    //mover la figura
    x1+=xpaso;
    y1+=ypaso;
    /*comprovar los limites cuando la ventan se reduzca y mientras la figura este rebotando y este se encuentre
    de repente fuera del area de recorte*/
    if(x1 > (windowWidth - tamano + xpaso))
    {
        x1=windowWidth - tamano - 1;
    }
    else if(x1 < -(windowWidth + xpaso) )
    {
        x1=-windowWidth - 1;
    }
    if(y1 < -(windowHeight - tamano + ypaso))
    {
        y1=windowHeight - tamano - 1;
    }
    else if(y1 > (windowHeight + ypaso) )
    {
        y1=-windowHeight - 1;
    }
    //volver a dibujar la figura con las nuevas coordenadas.
    glutPostRedisplay();
    glutTimerFunc(3300, TimerFunction, 1);
}
/////////////////
/// Principal ///
/////////////////

main(void)
{
    //Iniciamos el tipo de bufer esta vez sera doble.
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
    //Creamos ventana.
    glutCreateWindow("DobleBufer y animacion");
    //Llamamos a la funcion de dibujo.
    glutDisplayFunc(RenderEscena);
    //Llamamos a la funcion de control de dimensiones de la ventana
    glutReshapeFunc(ChangeTamano);
    // Llamamos a la funcion que establece la cantidad de tiempo para llamar a otra funcion en este caso la de movimiento.
    /*los parametros son (msec "milesimas de segundo que se debe esperar antes de ejecutar la funcion, 
    nombre de la funcion k llamamos, valor entero especificado por el usuario que le pasamos a la funcion) */
    glutTimerFunc(33, TimerFunction, 1);
    //Funcion de incializacion antes de la presentacion.
    SetupRC();
    glutMainLoop();
}

Taris · 24 de Agosto de 2005, 09:26:48 PM

Este es el primer tuto

Código [Seleccionar]


#include "gl/glut.h"


void Renderescena(void)
{
     //Esta funcion borra un bufer determinado o conjunto de estos. 
     //En opengl encontramos varios tipos de bufer (color, profundidad, plantillas y acumulacion)
     //En este caso borramos el bufer de color que es donde se encuentra la imagen guardada internamente y con esta funcion 
     //borramos el ultimo dibujo de la ventana.
    glClear(GL_COLOR_BUFFER_BIT);
    //Establecer un color para dibujar, en este caso el rojo. Los parametros son RGB.
    glColor3f(1.0f,0.0f,0.0f);
    /*Dibujar el rectangulo relleno con el color de dibujo. Los parametros pasados son coordenadas de puntos en diagonal
    (x1,y1)(x2,y2) En realidad lo que le decimos al ordenador es dibujar un diagonal desde el punte superior izquierdo
    hasta el punto inferior derecho*/
    glRectf(-25.0f,25.0f,25.0f,-25.0f);
    //ejecuta todos los comandos de opengl que no se hayan ejecutado ya.
    glFlush(); 
}

void SetupRC(void)
{
     //Establece el color de borrado de la pantalla(pero no la borra), en este caso ventana.
     //los parametros son rojo,verde,azul,alpha son de tipos float.
     glClearColor(0.0f,0.0f,1.0f,1.0f);
     
}
/*Opengl tiene sus propias variables, como por ejemplo esta: Glsizei es una variable numero entero de 32 bits.  
He puesto de nombre W y H  anchura y altura en ingles width y height.*/
//Esta funcion recibe la anchura y la altura siempre que canvia el tamaño de la ventana. Luego manipulamos la informacion.
void ChangeTamano (GLsizei w, GLsizei h)
{
     //Variable de opengl numero de coma flotante de 32 bits.
     GLfloat aspectRatio;
     //Para evitar la division entre 0.
     if(h==0)
     {
        h=1;
        //primero llamamos a esta funcion pasandole los parametros nuevos de anchura y altura (w,h).
        /*lo parametros de esta funcion son esquina inferior izquierda del puerto de vista, no de la ventana, coordenadas X e Y
        , los otros dos son anchura y altura del puerto de vista Width y height.
        Un puerto de vista defian el area donde dentro de la ventana donde opengl puede dibujar*/
        glViewport(0,0,w,h);
        /*Establecemos el sistema de coordenadas. Aunque estemos dibujando en 2D pensar que estamos en un sistema de dibujo de 3D
        por eso lo que hacemos es dejar el valor de la coordenada z en 0 y decirle al opengl que utilizamos una projeccion*/
        glMatrixMode(GL_PROJECTION);
        /*Reestablece el sistema de coordenadas antes de qualquier operacion de matriz, como por ejemplo glOrtho*/
        glLoadIdentity();
     }     
     //Establecer el volumen de recorte (izquierda,derecha, superior, inferior, cerca, lejos).
     //Nuestro volumen de recorte es el espacio de coordenadas visible.
     //aspectRatio o ratio de aspecto es una relacion de un numero de pixels sobre una longitud horizontal.
     aspectRatio=(GLfloat)w / (GLfloat)h;
     if(w<=h)
     {
        /*Esta funcion modifica el volumen de recorte existente, los parametros son (izquierda, derecha, inferior, superior, cerca,
        lejos). Multiplica de la matriz que describe el area de recorte actual
        por la que describimos en sus parametros.*/
        glOrtho(-100.0, 100.0, -100.0 / aspectRatio, 100.0 / aspectRatio, 1.0, -1.0);
        
     }
     else
     { 
        glOrtho( -100.0 * aspectRatio, 100.0 * aspectRatio, -100.0, 100.0, 1.0, -1.0);
        
        //esto indica que todas las transformaciones futuras afectaran a nuestro modelo.
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
     }//gracias a este if mantenemos el "cuadrado" cuadrado.
}
main(void)
{
          //Para establecer el modo del bufer. El bufer es donde se guardan los comandos de dibujo en este caso al ser simple
          //todos estos comandos se ejecutan en el dibujo de la ventana.
          glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
          //Crea la ventana y pone como titulo de esta simple.
          glutCreateWindow("Caudrado");
          
          //llama a la funcion que se encarga del borrado de pantalla o del bufer para ser mas exactos. Y luego dibuja la escena.
          //Bufer es una zona de almacenamiento de datos de la imagen. Los componentes de colo o de dibujo se conocen como:
          //bufer de color o bufer de pixeles.
          glutDisplayFunc(Renderescena);
          /*Detecta y controla los canvios en el tamaño en la ventana mediante otra funcion que nos devuelve el tamaño
          de la ventana (anchura y altura) para ello hemos creado la funcion que se llama ChangeTamaño (pondremos tamaño sin eñe
          para que no nos de problemas, que podria pasar)*/
          glutReshapeFunc(ChangeTamano);
          //esta funcion realiza cualquier inicializacion que deberiamos hacer de opengl antes de la presentacion.
          SetupRC();
          
          //Inicia la ejecucion de la estructura principal de la libreria glut y libera todas la s funciones de llamada y a glut.
          glutMainLoop();
       
}

ajmendoza · 24 de Agosto de 2005, 09:26:58 PM

Suele tener que ver con la proyección o que la camara se va a su casa cuando cambia de tamaño, pero no encuentro el error. Aunque estoy seguro que es que entre los comentarios el que sea ha matado un par de catedraticos de la lengua al escribir canviar :P.

DraKKaR · 25 de Agosto de 2005, 11:36:58 AM

No me gusta el

Código [Seleccionar]

if(h==0) que está en la función

Código [Seleccionar]

ChangeTamano. Eso hace que solo se especifique la matriz de proyección cuando la altura de la ventana sea 0. Creo que debería ser:

Código [Seleccionar]

if (h!=0) .

ajmendoza · 25 de Agosto de 2005, 11:44:04 AM

Cierto, eso está mal, ya que tendria que ser

if (f==0) {
f = 1;
}

...resto.

Eso solo sirve para que no divida entre 0 y pete el tema.

Taris · 25 de Agosto de 2005, 12:06:47 PM

Ya se lo que era, era un problema de corchetes como decis aki jejejejejeeje lo rectifike anoche a ultima hora (nooo) pero de todas maneras muchas gracias. jejejejejeje :P Mira k hay k ser tonto para cometer un error asi jejejejeje.

Hoy empiezo el dibujo espacial en 3D haber empezare dibujando puntos, que dibujen una forma si los unimos o algo asi haber k tal se me da jejejejejeje (ole)

Foros

Ka Falla O Falta En Estos Tutoriales De Opengl