Estoy empezando con openGL y trato de hacer algo muy simple:
Dibujar un cubo isométrico en el plano 3D.
Utilizo la vista Ortho pero no veo la forma de hacerlo.
Primero roto 45 grados en eje Y, hasta aqui ok; luego trato de rotar lo 30 en el eje X. Pero no sale como debiera.
Intentaré poner mi código mas tarde.
S2.
Creo que se lo que pasa... cuando usas glrotate y demas trasformas todo el sistema de coordenadas, es decir; cuando lo giras en el X se gira partiendo de como lo dejaste al rotarlo en Y.
Es algo que puee ser complejo, quiza lo mejor seria usar quaterniones o tener en cuenta la anterior rotacion.
Saludos.
const float lejos = 10;
const float sqrt3 = 1.0f/sqrt(3.0f);
gluLookAt(sqrt3*lejos,sqrt3*lejos,sqrt3*lejos,0,0,0, -1,-1,1);
Eso lo que hace es poner la cámara a la longitud lejos del punto origen. Si quisiera ir moviendola sería simple:
float pos[3];
gluLookAt(sqrt2*lejos +pos[0],sqrt2*lejos +pos[1] ,sqrt2*lejos + pos[2],pos[0],pos[1],+pos[2], -1,-1,1);
_Grey:
Si, creo que eso es lo que ocurre. De hecho buscaba una solución. Miraré haber lo de los Quaterniones.
¿Conoce alguien algun sitio donde lo expliquen bien clarito y aplicado a openGL?
Lo de LookAt() no me entero, ya me cuesta entender cómo funcionan las rotaciones... .Aunque tomo nota para mas adelante.
S2.
Bueno, gluLookAt es muy simple de entender. Olvidándonos de parámetros de funciones cuando definimos una cámara en lo que pensamos es en la típica cámara de cine. Si nos pusieramos a grabar en lo que pensamos es en dos cosas:
- donde ponernos
- a donde grabamos
Pues esto es lo que le debes decir a gluLookAt, donde está la cámara y a donde quieres que apunte.
Se tiene la posción de la cámara (x,y,z) y el punto donde quieres mirar (x0,y0,z0) pues para indicarselo a opengl se hace así:
gluLookAt(x,y,z, //donde está
x0,y0,z0, //a donde miramos
0,0,1); //olvida de momento estos 3 parámetros
el bucle principal de la aplicación sería asi:
void Render()
{
glClear(aquí los buffers);
glLoadIdentity(); //reset de la vista
gluLookAt(x,y,z, //donde está
x0,y0,z0, //a donde miramos
0,0,1); //olvida de momento estos 3 parámetros
dibujaObjetos();
}
espero que te sirva.
ethernet:
Vaya, tenías razón, no era tan difícil. Ya tengo mi cubo isométrico :) .
S2.
Nos debes un screenshot del cubo isométrico :P
Cita de: ethernetgluLookAt(x,y,z, //donde está
x0,y0,z0, //a donde miramos
0,0,1); //olvida de momento estos 3 parámetros
No seria mejor:
gluLookAt(x,y,z, //donde está
x0,y0,z0, //a donde miramos
0,1,0);
:huh: ?
El vector UP deberia de "mirar" hacia arriba, no?
Cita de: Lord Trancos 2Cita de: ethernetgluLookAt(x,y,z, //donde está
x0,y0,z0, //a donde miramos
0,0,1); //olvida de momento estos 3 parámetros
No seria mejor:
gluLookAt(x,y,z, //donde está
x0,y0,z0, //a donde miramos
0,1,0);
:huh: ?
El vector UP deberia de "mirar" hacia arriba, no?
Depende de cual sea tu arriba. Para mi mi arriba es Z > 0 por una sencilla razón: cuando se estudian las 2D se usan X e Y y para seguir siendo consistentes lo lógico si se añade una dimensión más sea Z, pero eso es una decisión personal, ya que la dimensión la puedes añadir para donde quieras... :)
Depende del sistema que esté usando:
- si los objetos se asientan sobre el plano XY es (0,0,1)
- si los objetos se asientan sobre el plano XZ es (0,1,0)
por cierto, en el código de antes hay sitios en los que puse sqrt2 y otros sqrt3. Obviamente es sqrt3 ya que si tenemos el vector (1,1,1) y lo normalizamos queda (1/sqrt(3),1/sqrt(3),1/sqrt(3)), de esta forma controlas la distancia al objetivo con precisión.
los de idsoftware usan tambien la z como altura, para alguien que empieza recomiendo usar 0,1,0 ya que la mayoria de los ejemplos que encontrara estan asi
si se añade una dimension mas existiendo x e y en pantalla, no se puede intercambiar la y para poner la z, x es horizontal e y vertical en 2d, pero claro esto es visto desde un monitor, si lo estudiamos sobre un plano y no sobre un monitor con referencia al usuario es como dice ethernet, en un plano reposando las dos dimensiones x e y son de desplazamiento no vertical
lo dejo mas claro aun por si alguien comienza flames por los gustos de ethernet que yo comparto ;) aunque puede que lo haya liado todo mas y se entienda menos :lol:
un saludo a todos
perdonar mi segundo post seguido pero es que los explique alreves y no me deja editarlo (nooo)
saludos
Lo lógico es usar el eje up en función de como exporte sus modelos, así se evita tener que andar cambiando ejes.
Bueno, ya que estamos y por no abrir otro post:
El cubo lo he realizado a mano con GL_QUADS para poder dar a cada cara un color distinto (no se si existe una funcion para ello, molaria saberlo)
El tema es que no veo posibilidad de representar el cubo con lineas y relleno de color al mismo tiempo. Parece que tiene que ser una wire o solid, no ambas a la vez.
Solose me ocurre una solucion "torpe":
Volver a dibujar encima del cuadrado de color otro cuadrado, esta vez con wire. Pero creo que es bastante estúpido.
Sin meternos en temas de materiales, sombreados y demás ¿es posible hacerlo?
S2.
en cada vertice debes de indicarle el color en rgb, para explicarte como hacerlo antes deberias poner como lo dibujas para saber como indicarle al opengl de donde obtener el color de cada vertice
no obstante te paso una pagina muy buena sobre opengl en el que encontraras un ejemplo de ello
pagina principal que te digo:
http://www.codesampler.com/oglsrc.htmpagina directa al ejemplo:
http://www.codesampler.com/oglsrc/oglsrc_1...primitive_types (es el ejemplo de primitivas)
saludos
pd: no se si te refieres a esto u otra cosa
CitarEl cubo lo he realizado a mano con GL_QUADS para poder dar a cada cara un color distinto (no se si existe una funcion para ello, molaria saberlo)
Pos que yo sepa no.
CitarEl tema es que no veo posibilidad de representar el cubo con lineas y relleno de color al mismo tiempo. Parece que tiene que ser una wire o solid, no ambas a la vez.
Efectivamente lo tendras que dibujar dos veces :(