[Tutorial] 2. Transparencias y luces.

Archivado
Hola a todos.

Este es el segundo tutorial de 3D en libnds. En el anterior tutorial dejé unas cuantas cosas sin explicar porque lo único que quería es que viérais un ejemplo sencillito de 3D sin usar ningún efecto raro. Hoy voy a explicar algunas propiedades de los polígonos, luces y transparencias.

Hay un máximo de 4 luces, y no se puede hacer transparente un cuerpo encima de otro transparente. Bueno, si se puede, pero salen cosas bastante raras...

Si tenéis cualquier duda preguntad.

--------------------------------------------------------------------------------------------
Las luces funcionan de la siguiente manera:

-Tienes que darle propiedades a los materiales de los polígonos. ¿Qué es eso? Pues decir cómo va a usar la información de las luces que configuremos. Podemos decir que refleje sólo la luz roja, que el propio cuerpo emita luz...

-Hay que configurar las luces (evidentemente). Para ello se da un color y un vector a la luz deseada. Por ejemplo, una luz RBG(31,31,31) con un vector (0,-1,0) es una luz blanca que cae del techo.

-Hay que decir en el formato de los polígonos que se va a usar la luz deseada (0 a 3). Puedes hacer que ciertas luces afecten a algunos objetos y a otros no, etc.

-Cuando estás dibujando el polígono en cuestión tienes que ir diciendo las normales de cada cara. ¿Qué son las normales? Una normal es un vector perpendicular a la superficie del polígono de longitud 1. Por ejemplo, la normal del suelo es (0,1,0) y la del techo (0,-1,0).

Menudo lío, ¿no? Afortunadamente, las 2 primeras cosas sólo se hacen una vez, la 3ª también lo normal es hacerla una vez (por frame) y la última no os preocupéis, que ya os daré un programita con el que se convierten modelos de un programa de diseño de 3D de ordenador en uno que la DS puede usar.
-------------------------------------------------------------------------------------------------
Las transparencias funcionan de la siguiente manera:

-Hay que activar GL_BLEND igual que el antialias.

-Hay que decir en el formato de los polígonos la cantidad de transparencia.

-Hay que tener en cuenta que solo se puede hacer transparencia de un objeto transparente sobre otro transparente si tienen distinta ID.

Eso es todo. La transparencia puede tomar valores de 0 a 31, 31 = cuerpo opaco, 1 a 30 = transparencia, 0 = solo se ven las aristas.
-------------------------------------------------------------------------------------------------
Las propiedades que se le pueden dar a los polígonos son las luces que vas a ver, toon shading, niebla, alpha (transparencia), el culling (partes del polígono que no se dibujan), la ID del polígono y algunas otras cositas. No voy a ver esto a fondo porque ni siquiera se como funcionana algunas cosas, pero os voy a decir los tipos de culling que hay:

POLY_CULL_FRONT No dibuja los polígonos de frente.
POLY_CULL_BACK     No dibuja los polígonos de espalda (lo recomendaría para polígonos no transparentes.)
POLY_CULL_NONE Dibuja todos los polígonos.
-------------------------------------------------------------------------------------------------

Estos son los ejemplos:


Luces y culling:

main.c:
#include <PA9.h>


void Dibujar3D();

int rot_quad;

bool culling; //Para hacer culling o no.

int main()
{    
PA_Init();
PA_InitVBL();

PA_InitText(1, 0);
PA_OutputText(1,0,0,"Tutorial de 3D usando libnds\npor AntonioND.\n\n\nEsto es un ejemplo de libnds\nmodificado.");

PA_OutputText(1,0,10,"A: Cambiar culling.\nB: Mover.");


videoSetMode(MODE_0_3D);

glInit();
glEnable(GL_ANTIALIAS);

glClearColor(0,0,0,31);
glClearPolyID(63);
glClearDepth(GL_MAX_DEPTH);

glViewport(0,0,255,191);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(70, 256.0 / 192.0, 0.1, 100);

//Configura la luz 0 con un color RGB15(31,0,0) = Rojo, con un vector (0,-1,0)
glLight(0, RGB15(31,0,0) , 0, floattov10(-1.0), 0);
//Luz 1, color RGB15(0,31,0) = Verde, vector (0,1,0)
glLight(1, RGB15(0,31,0) , 0, floattov10(1.0) , 0);
//Luz 2, color RGB15(0,0,31) = Azul
glLight(2, RGB15(0,0,31) , floattov10(1.0), 0, 0);
//RGB15(31,31,0) = Amarillo
glLight(3, RGB15(31,31,0) , floattov10(-1.0), 0, 0);


//Comportamiento de los materiales respecto a la luz.
//El color en RGB15 es el máximo color que puede tener el polígono por ese tipo de luz.
//Por ejemplo, si tengo una luz de RGB15(31,31,31) pero el material GL_DIFFUSE es
//RGB15(16,16,16), el color máximo que puede alcanzar por la luz es RGB15(16,16,16).
//Lo otro es la propiedad, lo he explicado un poco.

//Color reflejado por la pared, suelo...
glMaterialf(GL_AMBIENT, RGB15(8,8,8));
//Luces que dan diréctamente a el polígono.
glMaterialf(GL_DIFFUSE, RGB15(31,31,31));
//Color que se refleja a la cámara (como en un espejo)...
glMaterialf(GL_SPECULAR, 0);
//Color que emite el propio polígono.
glMaterialf(GL_EMISSION, RGB15(5,5,5));

while (1)
{
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

culling ^= Pad.Newpress.A;

rot_quad -= Pad.Held.B;

//Dibujar la escena
Dibujar3D();

glFlush(0);
PA_WaitForVBL();
}

return 0;
}

void Dibujar3D()    
{    
//Atributos de los polígonos    
if(culling)    
{
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_FRONT | POLY_FORMAT_LIGHT0 | POLY_FORMAT_LIGHT1 |
POLY_FORMAT_LIGHT2 | POLY_FORMAT_LIGHT3);
}
else
{
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE | POLY_FORMAT_LIGHT0 | POLY_FORMAT_LIGHT1 |
POLY_FORMAT_LIGHT2 | POLY_FORMAT_LIGHT3);
}

glTranslatef(0.0f,0.0f,-3.0f);

glRotateX(rot_quad);
glRotateY(rot_quad);
glRotateZ(rot_quad);
glBegin(GL_QUADS);
//La normal es el vector perpendicular a una cara, se usa para las luces y debe
//estar normalizada (tiene que medir 1)
glNormal3f( 0.0f, 0.0f, 1.0f);
glVertex3f(-1.0f, -1.0f,  1.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
glVertex3f( 1.0f,  1.0f,  1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);

glNormal3f( 0.0f, 0.0f,-1.0f);
glVertex3f(-1.0f, -1.0f, -1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
glVertex3f( 1.0f,  1.0f, -1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);

glNormal3f( 0.0f, 1.0f, 0.0f);
glVertex3f(-1.0f,  1.0f, -1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
glVertex3f( 1.0f,  1.0f,  1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);

glNormal3f( 0.0f,-1.0f, 0.0f);
glVertex3f(-1.0f, -1.0f, -1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
glVertex3f( 1.0f, -1.0f,  1.0f); glVertex3f(-1.0f, -1.0f,  1.0f);

glNormal3f( 1.0f, 0.0f, 0.0f);
glVertex3f( 1.0f, -1.0f, -1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
glVertex3f( 1.0f,  1.0f,  1.0f); glVertex3f( 1.0f, -1.0f,  1.0f);

glNormal3f(-1.0f, 0.0f, 0.0f);
glVertex3f(-1.0f, -1.0f, -1.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
glVertex3f(-1.0f,  1.0f,  1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
glEnd();

return;
}



Blending  (gracias a Dr.Demencio):

#include <PA9.h>

void Dibujar3D();

float rot_tri, rot_quad;

int main()
{    
PA_Init();
PA_InitVBL();

PA_InitText(1, 0);

PA_OutputText(1,0,0,"Tutorial de 3D usando libnds\npor AntonioND.\n\n\nEsto es un ejemplo de libnds\nmodificado.");

PA_OutputText(1,0,10,"Arriba/Abajo: Cambiar\n              transparencia.");

videoSetMode(MODE_0_3D);

glInit();
//Activar blending y antialias
glEnable(GL_ANTIALIAS | GL_BLEND);

glClearColor(0,0,0,31);
glClearPolyID(63);
glClearDepth(GL_MAX_DEPTH);

glViewport(0,0,255,191);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(70, 256.0 / 192.0, 0.1, 100);

u8 blending = 15;

while (1)
{
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

if(blending < 31 && Pad.Newpress.Up) blending ++;
if(blending > 0 && Pad.Newpress.Down) blending--;

rot_tri+=0.5f;
rot_quad-=0.3f;

//Las caras traseras tienen ID 0
glPolyFmt(POLY_ID(0) |POLY_ALPHA(blending) | POLY_CULL_FRONT);
Dibujar3D();

//Las caras delanteras tienen ID 1
glPolyFmt(POLY_ID(1) |POLY_ALPHA(blending) | POLY_CULL_BACK);
Dibujar3D();

glFlush(0);
PA_WaitForVBL();
}

return 0;
}

void Dibujar3D()    
{
glLoadIdentity();
glTranslatef(-1.5f,0.0f,-6.0f);
glRotateY(rot_tri);
glBegin(GL_TRIANGLES);    
glColor3f(1.0f,0.0f,0.0f);
glVertex3f( 0.0f, 1.0f, 0.0f);    
glColor3f(0.0f,1.0f,0.0f);
glVertex3f(-1.0f,-1.0f, 1.0f);    
glColor3f(0.0f,0.0f,1.0f);    
glVertex3f( 1.0f,-1.0f, 1.0f);    
glColor3f(1.0f,0.0f,0.0f);
glVertex3f( 0.0f, 1.0f, 0.0f);    
glColor3f(0.0f,0.0f,1.0f);    
glVertex3f( 1.0f,-1.0f, 1.0f);
glColor3f(0.0f,1.0f,0.0f);    
glVertex3f( 1.0f,-1.0f, -1.0f);
glColor3f(1.0f,0.0f,0.0f);    
glVertex3f( 0.0f, 1.0f, 0.0f);    
glColor3f(0.0f,1.0f,0.0f);    
glVertex3f( 1.0f,-1.0f, -1.0f);
glColor3f(0.0f,0.0f,1.0f);    
glVertex3f(-1.0f,-1.0f, -1.0f);
glColor3f(1.0f,0.0f,0.0f);    
glVertex3f( 0.0f, 1.0f, 0.0f);    
glColor3f(0.0f,0.0f,1.0f);    
glVertex3f(-1.0f,-1.0f,-1.0f);
glColor3f(0.0f,1.0f,0.0f);    
glVertex3f(-1.0f,-1.0f, 1.0f);    
glEnd();

glLoadIdentity();
glTranslatef(1.5f,0.0f,-7.0f);
glRotateX(rot_quad);
glRotateY(rot_quad);
glRotateZ(rot_quad);
glBegin(GL_QUADS);
glColor3f(0.0f,1.0f,0.0f);    
glVertex3f( 1.0f, 1.0f,-1.0f);
glVertex3f(-1.0f, 1.0f,-1.0f);    
glVertex3f(-1.0f, 1.0f, 1.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);    
glColor3f(1.0f,0.5f,0.0f);
glVertex3f( 1.0f,-1.0f, 1.0f);    
glVertex3f(-1.0f,-1.0f, 1.0f);    
glVertex3f(-1.0f,-1.0f,-1.0f);    
glVertex3f( 1.0f,-1.0f,-1.0f);
glColor3f(1.0f,0.0f,0.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);    
glVertex3f(-1.0f, 1.0f, 1.0f);    
glVertex3f(-1.0f,-1.0f, 1.0f);    
glVertex3f( 1.0f,-1.0f, 1.0f);    
glColor3f(1.0f,1.0f,0.0f);    
glVertex3f( 1.0f,-1.0f,-1.0f);    
glVertex3f(-1.0f,-1.0f,-1.0f);    
glVertex3f(-1.0f, 1.0f,-1.0f);    
glVertex3f( 1.0f, 1.0f,-1.0f);    
glColor3f(0.0f,0.0f,1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);    
glVertex3f(-1.0f, 1.0f,-1.0f);    
glVertex3f(-1.0f,-1.0f,-1.0f);    
glVertex3f(-1.0f,-1.0f, 1.0f);    
glColor3f(1.0f,0.0f,1.0f);    
glVertex3f( 1.0f, 1.0f,-1.0f);    
glVertex3f( 1.0f, 1.0f, 1.0f);    
glVertex3f( 1.0f,-1.0f, 1.0f);    
glVertex3f( 1.0f,-1.0f,-1.0f);    
glEnd();

return;
}


Despues de compilar tendremos estos resultados:
Imagen

Imagen
Descarga:
http://www.mediafire.com/?wif5djmelxg
Muxas gracias por el tuto, a un sprite tambien puedes acer k se transparente??
nazareth escribió:Muxas gracias por el tuto, a un sprite tambien puedes acer k se transparente??

A un sprite 3D sí. El próximo tuto será de texturas y tal vez de tipos de proyección (ortogonal y normal). Si usas cuadrados con texturas en una proyección ortogonal los verás como imágenes planas, pero como en realidad son figuras 3D les puedes hacer lo que te de la gana :P.
OK, entonces para acer k un sprite 2D se transparnte dandole acia arriba y acia abajo, como seria??? se puede acer???
nazareth escribió:OK, entonces para acer k un sprite 2D se transparnte dandole acia arriba y acia abajo, como seria??? se puede acer???

¿Con sprites 2D dices? No se como se hace con el hardware 2D, con el 3D si. Si me hablas de PAlib seguro que hay algo por ahí, pero creo recordar que el sistema dejaba mucho que desear...

Si es con 3D espérate a que hable de texturas y esas cosas mejor.
Buenos tutos ANTONIOND.
Sobre lo de las transparencias, yo no se como funcionará en la DS, pero si se parece a como va en PC, la cosa es que para que quede bien tiene que ordenar los triángulos para que se pinten de más lejos a más cerca.
Un buen ejemplo de lo que pasa si no haces esto es el FF3. Cuando matas a un enemigo se veen cosas raras. Afortunadamente es algo que han solventado en el 4, al parecer.
He estado investigando un poco por lo que me has dicho del FF4. He leído que se puede hacer si cambias la ID del polígono. Voy a hacer unas pruebas a ver que tal. Si funciona cambio un par de cosas en el tutorial y listo.

EDIT: Puede que el problema sea que las caras no tienen un color, sino que son las luces lo que se lo dan...

EDIT2: He probado modificando el ejemplo del primer tutorial activando el blending, cambiando la ID por cada cara que dibujo... Y nada, siguen saliendo las cosas raras... Si alguien sabe como arreglarlo estaré encantado si me lo explica (así cambio el tutorial). Por cierto, se me ha olvidado hablaros de lo de las IDs de los polígonos... También influye en el antialias... Ya lo pongo en el próximo tuto...

EDIT3: VALE, ya se como arreglarlo...

EDIT4: [buuuaaaa] [buuuaaaa] Mierda, ya se como se arregla y es un coñazo...
Para objetos simples lo que se me ocurre que podrías hacer es dibujar en 2 pasadas: primero activando el front culling y depués con el back culling. Pero claro, esto sólo valdría para objetos que no tengan varias caras una detrás de otra apuntando en la misma dirección (esferas, cubos, pirámides...) y si tienes varios también tendrías que ordenar los objetos. Para juegos en 2.5D se puede dejar todo precalculado (que digo yo que es el truco que utilizan en el FF4), pero si la cámara puede cambiar de ángulo no hay más remedio que hacerlo en tiempo de ejecución. Ciertamete es complicado utilizar esto de las transparencias en el caso general.
Dr.Demencio escribió:Para objetos simples lo que se me ocurre que podrías hacer es dibujar en 2 pasadas: primero activando el front culling y depués con el back culling. Pero claro, esto sólo valdría para objetos que no tengan varias caras una detrás de otra apuntando en la misma dirección (esferas, cubos, pirámides...) y si tienes varios también tendrías que ordenar los objetos. Para juegos en 2.5D se puede dejar todo precalculado (que digo yo que es el truco que utilizan en el FF4), pero si la cámara puede cambiar de ángulo no hay más remedio que hacerlo en tiempo de ejecución. Ciertamete es complicado utilizar esto de las transparencias en el caso general.

Yo lo estaba haciendo cambiando la ID de cada polígono (de ahí lo del coñazo)... Voy a probar lo de front y back culling.

EDIT: Funciona. Es tan simple que funciona. Creo que lo voy a dejar con lo de front y back, que tampoco hay que complicarse mucho la vida. Aunque la forma buena es cambiando la ID de cada polígono... Y aún así hace cosas raras XD, pero esas son pasables.

EDIT2: Arreglado.
Gracias por hacer estos tutoriales desinteresadamente.
Fusion_X escribió:Gracias por hacer estos tutoriales desinteresadamente.

Si... Desinteresadamente... [360º]  [sonrisa]
Que si hombre, gracias.

PD: Dentro de unos días voy a sacar un programita con 10 demos de 3D (source incluído). Os dejo una captura de una de ellas, ya os he enseñado 2 en el otro tutorial:
Imagen
Concretamente esta va a 15-20 FPS en el mejor de los casos (la calidad se paga XD), pero las demás van a 60.
Joder, y yo lo único que necesito saber es hacer las animaciones, y cargar el modelo 3D de la cara de Abe, Sligs, Scrabs...
¿Cómo cargas los modelos, con display lists?

EDIT: Aaaaaa, que no sabes cómo cargarlos XD. En un tuto (el 5) diré como. Y si eso digo cómo los animo yo en el BlobbDS.
La verdad es que lo de hacer animaciones es algo en lo que OpenGL no ayuda demasiado. Si simplemente vas a mover una serie de mallas estáticas (sin ningún tipo de deformación) que formen un modelo partido a cachos (como ocurre por ejemplo en el FF7) puedes recorrer el esqueleto e ir acumulando transformaciones geométricas (glRotate/glTranslate) sin olvidar almacenar la actual (glPushMatrix) y dibujando la parte que vaya a cada hueso (y al final de cada rama volver atrás con glPopMatrix). Si lo que quieres es deformar la malla, ya vas a necesitar calcular tu mismo (o con una librería especializada) la posición de cada vértice. De hecho en este último caso ni siquiera puede utilizar display lists (lo mejor sería usar vertex arrays, no se si la DS los soporta).
También está el método del año de la pera de tener cargados cada uno de los frames del modelo como una display list distinta. Pero los 4 Mbs de la DS no parecen aconsejar desperdiciar memoria de esa manera...
Por cierto, quienes son esos Abe, Sligs y Scrabs?
Dr.Demencio escribió:La verdad es que lo de hacer animaciones es algo en lo que OpenGL no ayuda demasiado. Si simplemente vas a mover una serie de mallas estáticas (sin ningún tipo de deformación) que formen un modelo partido a cachos (como ocurre por ejemplo en el FF7) puedes recorrer el esqueleto e ir acumulando transformaciones geométricas (glRotate/glTranslate) sin olvidar almacenar la actual (glPushMatrix) y dibujando la parte que vaya a cada hueso (y al final de cada rama volver atrás con glPopMatrix). Si lo que quieres es deformar la malla, ya vas a necesitar calcular tu mismo (o con una librería especializada) la posición de cada vértice. De hecho en este último caso ni siquiera puede utilizar display lists (lo mejor sería usar vertex arrays, no se si la DS los soporta).
También está el método del año de la pera de tener cargados cada uno de los frames del modelo como una display list distinta. Pero los 4 Mbs de la DS no parecen aconsejar desperdiciar memoria de esa manera...
Por cierto, quienes son esos Abe, Sligs y Scrabs?


No se lo que es un vertex array, asi que supongo que la DS no lo soporta (por lo menos no lo he visto en las libnds).

Una display list no ocupa mucho. Se pueden cargar varias en la memoria y irlas usando para animar. Yo personalmente las dejo cargo de FAT cuando las necesito. Es decir, cargo de fat y le paso el puntero de la display list a la función glCallList(). Como ocupan poco se puede hacer sin que le cueste mucho al juego, y créeme, 5kb que ocupa una DL (la más grande que tengo en mi juego) no es nada, es más preocupante el tema de las texturas XD. Ten en cuenta que la DS no pasa de 6000 y pico vértices por frame (se pueden hacer truquitos para aumentarlo, pero se reducen a la mitad los FPS).

Esos nombres son de personajes del juego que está haciendo (portando) a DS.

PD: http://forum.gbadev.org/viewtopic.php?t=14947
ANTONIOND escribió:¿Cómo cargas los modelos, con display lists?

EDIT: Aaaaaa, que no sabes cómo cargarlos XD. En un tuto (el 5) diré como. Y si eso digo cómo los animo yo en el BlobbDS.

Hmm ¬.¬
Mira mi mensaje anterior... Sobre todo la PD...
Pues no, parece que libnds no soporta vertex arrays. Básicamente consiste en dibujar con una única función una serie de polígonos a partir de una lísta de vértices y una lísta de índices (de 3 en 3) que definan los polígonos (y, opcionalmente, listas de normales, coordenadas de textura...) que se pueda cambiar en cualquier momento (las display lists se almacenan en la memoria de la gráfica y son intocables). Así se consigue aumentar la velocidad respecto al modo inmediato (sólo una llamada para pintar todas las primitivas) y se mantiene la flexibilidad. Aunque hechandole un ojo a la documentación de la función glCallList tiene pinta de que aquí su significado es bastante distinto. Parece que las display lists estan pre-compiladas y se mandan manualmente a dibujar.
Pero bueno, si dices que ocupan menos de 5 kbs, pues bien está. Aunque si hay varios personajes con una serie de animaciones medianamente largas puede ser un problema.
PD.: Juer, se nota que la gráfica de la DS es rarita. Vaya operaciones más raras que se calza...
Dr.Demencio escribió:Pues no, parece que libnds no soporta vertex arrays. Básicamente consiste en dibujar con una única función una serie de polígonos a partir de una lísta de vértices y una lísta de índices (de 3 en 3) que definan los polígonos (y, opcionalmente, listas de normales, coordenadas de textura...) que se pueda cambiar en cualquier momento (las display lists se almacenan en la memoria de la gráfica y son intocables). Así se consigue aumentar la velocidad respecto al modo inmediato (sólo una llamada para pintar todas las primitivas) y se mantiene la flexibilidad. Aunque hechandole un ojo a la documentación de la función glCallList tiene pinta de que aquí su significado es bastante distinto. Parece que las display lists estan pre-compiladas y se mandan manualmente a dibujar.
Pero bueno, si dices que ocupan menos de 5 kbs, pues bien está. Aunque si hay varios personajes con una serie de animaciones medianamente largas puede ser un problema.
PD.: Juer, se nota que la gráfica de la DS es rarita. Vaya operaciones más raras que se calza...

OK, gracias por la información. En efecto, las display lists las tienes que hacer tú en el ordenador a partir de un programa que convierta los modelos a .bin (y luego incluyes el .bin) o las escribes como en el ejemplo "C:\devkitPro\examples\nds\Graphics\3D\Misc\Display_List" (pero esto no es una buena idea, creo yo). Lo del tamaño no es problema. Si la DL ocupa mucho lo mas seguro es que estés usando demasiados polígonos para la DS y tengas que simplificar los modelos.

Te voy a decir como van las DL de DS. Todos los bloques que voy a decir son s32.
-1º Número de bloques sin contar éste.
-2º Bloque de comandos empaquetados (hasta 4) de modo que cada uno ocupa 1 byte.
http://nocash.emubase.de/gbatek.htm#ds3diomap (Geometry Commands, el "cmd".)
-3º Parámetros de cada comando si hacen falta, por orden (evidentemente). El número de parámetros es el "pa." en esa web. Indica el número de bloques que se usarán para ese comando.
-4º Volver al 2 y repetir hasta el final. Creo que hay un límite de tamaño, pero no se cual es.

Sacado del ejemplo que te he dicho antes de libnds:
u32 triangle[] =
{
12, //Número de bloques

FIFO_COMMAND_PACK(FIFO_BEGIN, FIFO_COLOR, FIFO_VERTEX16, FIFO_COLOR), //Comandos empaquetados

GL_TRIANGLE,//Parámetros
RGB15(31,0,0),
VERTEX_PACK(inttov16(-1),inttov16(-1)), VERTEX_PACK(0,0),
RGB15(0,31,0),

FIFO_COMMAND_PACK(FIFO_VERTEX16, FIFO_COLOR, FIFO_VERTEX16, FIFO_END), //Repetir
VERTEX_PACK(inttov16(1),inttov16(-1)), VERTEX_PACK(0,0),
RGB15(0,0,31),
VERTEX_PACK(inttov16(0),inttov16(1)), VERTEX_PACK(0,0),
};



Por eso ocupan tan poco, en unos pocos bytes metes toda la información que quieras. El programa de mi mensaje anterior hace todo esto solo, evidentemente... Lo de los 5kbs es mi caso, pero normalmente andarán por ahí.

Además las DL pueden tener cualquier comando que se pueda enviar al hardware de 3D, por lo que una DL se puede cargar toda la escena si modifica la matriz, por ejemplo. XD


PD: Los que estáis empezando pasad de esto, no necesitáis saberlo para nada. Creo que no tendría que haberlo puesto aquí. [+risas]
Ya veo, está crurioso esto. Muchas gracias por la información ANTONIOND.
Edit: Sorry...
Dr.Demencio escribió:Ya veo, está crurioso esto. Muchas gracias por la información ANTONIOID.


Corrijo: ANTONIOND. Descompuesto:
Antonio
Niño
Díaz.
Joder, si lo pone en sus muestras XD
Exactamente. XD No pasa na, no eres el primero que se equivoca y no serás el último...


Por cierto, lo de antes no es que sean s32, es que ocupan 4 bytes y como en todos los lados pone que se usa este tipo de variable y tengo que pasar punteros en s32 pues ya es la costumbre de verlo, jeje.
21 respuestas
Archivado
Volver a Scene