Ser o no ser?

[Lord Trancos]

                                Ya q se esta hablando de los octrees... que opinais acerca de cortar los poligonos para crear el octree ? cortar o no cortar, esa es la cuestion... :sonriendo:

^_^                                

[NeLo]

                                Hi Lord Trancos.

Pensando en la potencia de las tarjetas gráficas actuales, no veo muy necesario cortar los poligonos, si tiene un vertice dentro, pues a renderizarlo. Aunque lo que si se debe mirar es que un polígono que pertenezca a dos nodos no se renderize dos veces :ojo:

Bye.                                

[Drácula]

                                No cortar! Si cortas no podrás tener un mundo dinámico!! Aunque como bien han dicho..¡no lo dibujes 2 veces!

Por cierto, se habla mucho de los octrees, pero en portales, casi siempre es suficiente con un Quadtree!!                                

[Emotion]

                                Por supuesto, NO cortar, ya que con los calculos basicos del octree, ya esta bien hecho.

Ademas, con los niveles de proceso que ya llevas, deberia ser mas que suficiente para cumplir todas tus expectativas, ya que el esquema ideal para aceleracion de superficies es el ya conocido:

INPUT > VSD > HSR > VS > OUTPUT

Es decir, primero el Octree (como VSD o Visual Surface Determination), luego el Backface Culling + el Frustum (HSR o Hidden Surface Removal) y despues, aunque opcional, el Striping (Triangle Strip) o el Vertex Array (VAR o metodo simple), antes de mandar los poligonos al renderer de la tarjeta.

Supongo que estas mandando los poligonos uno detras de otro sin propiedades especiales de materiales o datos sobre optimizacion de poligonos, no?

Por cierto... donde esta ahora el smile verde???? ME LO HAN ROBADO!!! :sonriendo:

Saludos.
                               

[BeRSeRKeR]

                                Jeje la verdad es que el verde molaba más, eh? :riendo:                                

[Emotion]

                                totalmente de acuerdo... a este smile parece que le hayan estirado la piel como a las famosas... cuidado no vaya a ser que de tanto reirse se le caigan las pestañas jurjur...

Saludos
                               

[BeRSeRKeR]

                                :riendo: ...si te fijas parece Joker :ojo:                                

[BeRSeRKeR]

                                por cierto, en referencia al tema que nos trajo aqui...¡NO CLIPPING!...pero no sólo para octrees, quadtrees...tampoco para portal rendering :ojo:

PD: Esto ha sido una excusa para probar a meter mi firma...a ver como queda :riendo:

_________________
BeRSeRKeR
http://www.planetquake.com/digitalys">DiGiTALYS TEAM

[ Este Mensaje fue editado por: BeRSeRKeR el 2002-03-20 18:43 ]                                

[Lord Trancos]

                                Vale, sois unanimes en cuanto a que no se deben de cortar los poligonos.

Pero,... si no los corto, cual es la mejor forma (la mas rapida) de dibujarlos. Ya que le he dado muchas vueltas y no encuentro una forma que me guste.

No hace mucho estuve viendo un ejemplo de los de ATI (creo) que usaba un octree con poligonos cortados, y me parecio que la forma de renderizarlo era bastante mas facil que si no los cortaba.

Si no los corto, debo de tener una lista con que poligonos llevo dibujados y cuales no... lo cual son un buen monton de comprobaciones y ademas, ¿ tengo que ir creando "on-the-fly" los vertex buffers (o index buffers) para enviarselos al DX ?

La verdad, es que estoy bastante perdido y os agradezco toda la ayuda que me estais dando. :sonriendo:

Si os motiva en algo, os dire que quiero hacer un ejemplo sobre los octrees y colgarlo en mi web (dxlab.tk) para que sirva a otros :ojo:

Un Saludo :riendo:

PD: A mi tb me gustaba mas el smile verde                                

[Drácula]

                                Si no los cortas, significa que tienes que crear dinámicamente la lista. De ahí que los vertex buffers sean una ##$$%% para temas dinámicos.

Lo que dices de que tienes que saber cuales has dibujado ya y cuales no...¡es cierto! Pero sólo necesitas saber esto y listo. Si no sabes como hacerlo, te pasaré código!                                

[Klinex]

                                Dracula podrias tambien pasarme el codigo a mi por favor? (si no es mucho pedir).

Un saludo.                                

[Lord Trancos]

                                Vale, los vertex buffers seran una mierda, pero estoy usando directX y no me hace ilusion cambiar de API. ¿cual es la mejor forma de montar/dibujar un octree usando DX8?

En cuanto a enviarme codigo,... te lo agradeceria mucho (lordtrancos@softhome.net), aunque sea en opengl o sdl o yoquese, ya que siempre puedo aprender algo :ojo:

Tengo 2 ejemplos de octree:

 uno es este: http://www.cone3d.0catch.com/tutorials/tut3/index.html

 que esta muy bien, pero para dibujarlo usa esto:



   // Loop through all the triangles
   for(int i=0;i    {
     // Check if the triangle has been drawn in this frame. If not, then draw it
     if(pcount[trigz.ID] != framenr)
     {
       pcount[trigz.ID] = framenr;
       glBindTexture(GL_TEXTURE_2D,textures[trigz.texture]);
       glBegin(GL_TRIANGLES);
       glTexCoord2f(trigz.vertex[0].u,trigz.vertex[0].v);
       glVertex3f(trigz.vertex[0].x,trigz.vertex[0].y,trigz.vertex[0].z);

       glTexCoord2f(trigz.vertex[1].u,trigz.vertex[1].v);
       glVertex3f(trigz.vertex[1].x,trigz.vertex[1].y,trigz.vertex[1].z);

       glTexCoord2f(trigz.vertex[2].u,trigz.vertex[2].v);
       glVertex3f(trigz.vertex[2].x,trigz.vertex[2].y,trigz.vertex[2].z);
       glEnd();
       polyz++;
     }
   }


yo de opengl no se, pero esto parece que los dibuja de 1 en 1,... cosa q me parece muy lenta y ademas no encaja muy bien con la "filosofia" de los vertex/index buffers.

El otro hace algo parecido pero peor (pq redibuja los poligonos que pertenecen a varios nodos).

A parte de estos 2. Tengo un ejemplo que usa DirectX + Octree que es el que comente de ATI, pero ellos dividen los poligonos.... :-/

[ Este Mensaje fue editado por: Lord Trancos el 2002-03-23 21:53 ]

[ Este Mensaje fue editado por: Lord Trancos el 2002-03-23 21:56 ]                                

[Drácula]

                                Voy a explicaros cómo lo haría yo:

Por una parte tengo los vértices e índices del objeto. Aquí tengo TODOS los vértices e índices del objeto sibn subdividir. Además tengo un array que me indicará si ha lo he dibujado o no:
D3DVERTER vertices[NumVertices];
WORD indices[NumCaras][3];
BYTE dibujado[NumCaras];

Aparte tengo la información en el Octree de que índice de cara pertenece a que subdivisión:

WORD division[];

Es decir, que por un lado tengo el objeto y por otro que caras hay que dibujar.

¡Pues ya está! A la hora de dibujar una subdivisión del Octree, sólo tenemos que comprobar antes si ya ha sido dibujada esta cara!

Supongo que el problema lo teniais si tratabais las subdivisiones del Octree como un objeto a parte, es decir, cada subidivisón tenía sus caras y sus vértices... En ese caso es muy difícil saber que cara ya se ha dibujado, puesto que CADA subidivisón tiene sus propias caras. Pero co el método expuesto antes, este problema..¡desaparece!

Otro problema es, como ya habreis deducido, el de cómo dibujar las caras. Si las dibujamos de una en una parece que todo irá muy lento, puesto que ya no podemos utilizar el sistema indexado, que es sin lugar a dudas el más rápido.
Bien, este problema se resuelve de diferentes maneras, pero es un poco complejo:
1) Ir añadiendo las caras en un array y al final convertir este array a un array indexado de caras. No es costoso y no precisa de mucho tiempo. Sin embargo en objetos con muchos vértices, las comprobaciones son enormes.
2) Controlando qué vértices NO se utilizan y eliminándolos de la lista. Esta opción funciona mucho mejor con un gran número de vértices.
3) Olvidarme de problemas y hacerlo de uno en uno. Esta es la mejor opción desde mi punto de ver cuando el nº de vértices es pequeño.

Bueno, espero que os haya sido de ayuda.                                

[Gunder]

                                Buenas,

por aportar algo al tema, yo apuntaria la posibilidad de tener en cada nodo un PVS para reducir a lo ridiculo la comprobacion de si un nodo esta en visual o no.

Respecto a si dividir o no dividir, NO DIVIDIR!!!

Pero y esto lo dejo en el aire, seria buena la posiblidad de organizar grupos de vertices q esten comprendidos en un nodo y vertices q esten en varios para así poder añadir vertices al vertex buffer cuando toque renderizar ese nodo pero... ¿ como hacerlo ?, la verdad esque lo veo muy complicado pero seguro q alguien saca alguna buena idea, quizas almacenar en nodos superiores o yo que se.

Seguro q alguien tiene una buena idea.

Ale.
Gunder                                

[_Grey]

                                Me gustaria seguir con el tema de los vertexbuffer...:

Los metodos que hemos comantado parecen no ser del todo perfectos, yo creo que tiene una sencilla solucion, deveriamos de tener un vertexbuffer con todos los vertices de la "estancia"(por llamarla de una forma :ojo:), y luego tener un indexbuffer con los poligonos de esta , pero , ordenados segun el nodo del octree al que pertenecen, osea , p.ej.:Los 50 primeros poligons corresponden al primer nodo los 45 siguientes al segundo, y asi con todos , asi , cuando tengamos que dibujar los poligonos de un nodo "visible" del octree bastaria con el DrawIndexPrimitive() al que se le pasarion los valores de los poligonos correspondientes al nodo "que se ve".

Respecto a cortar o no cortar, podemos cortar por lo sano... podemos duplicar ese poligono y dibujarlo dos veces(ya se que no os gusta!) o podemos crear nodos "especiales",donde se pongan los poligonos que pasan por varios nodos (los mismos para todos los poligonos! si no , otro nodo, "especial") y pasarles el DrawIndexPrimitive() correspondiente si uno de esos nodos "asociados a ellos" es "visibles".

Espero no complicarlo mas.

Saludos.