Corregirme si me equivoco. Frustrum culling es determinar la parte que quiero que se renderize de mi escena. Creo que es una especie de cubo.
¿ Como se consigue ?
En ese tutorial no explica ni de lejos como saca los planos del frustrum el se limita a sacarlos. Aprovecho para ver si alguien sabe una web donde d una eplicacion matematica .
saludos
hay que ver como te complicas ethernet xD
se saca de la matriz resultante de multiplicar la matriz de vista por la de proyección.
dev->GetTransform(D3DTS_PROJECTION,&matproj);
dev->GetTransform(D3DTS_VIEW,&matview);
D3DXMatrixMultiply(&Matrix,&matview,&matproj);
// calculamos los planos
m_Planes[0].a = Matrix._14 + Matrix._13; // plano cercano
m_Planes[0].b = Matrix._24 + Matrix._23;
m_Planes[0].c = Matrix._34 + Matrix._33;
m_Planes[0].d = Matrix._44 + Matrix._43;
D3DXPlaneNormalize(&m_Planes[0], &m_Planes[0]);
m_Planes[1].a = Matrix._14 - Matrix._13; // plano lejano
m_Planes[1].b = Matrix._24 - Matrix._23;
m_Planes[1].c = Matrix._34 - Matrix._33;
m_Planes[1].d = Matrix._44 - Matrix._43;
D3DXPlaneNormalize(&m_Planes[1], &m_Planes[1]);
m_Planes[2].a = Matrix._14 + Matrix._11; // plano izquierda
m_Planes[2].b = Matrix._24 + Matrix._21;
m_Planes[2].c = Matrix._34 + Matrix._31;
m_Planes[2].d = Matrix._44 + Matrix._41;
D3DXPlaneNormalize(&m_Planes[2], &m_Planes[2]);
m_Planes[3].a = Matrix._14 - Matrix._11; // plano derecha
m_Planes[3].b = Matrix._24 - Matrix._21;
m_Planes[3].c = Matrix._34 - Matrix._31;
m_Planes[3].d = Matrix._44 - Matrix._41;
D3DXPlaneNormalize(&m_Planes[3], &m_Planes[3]);
m_Planes[4].a = Matrix._14 - Matrix._12; // plano de arriba
m_Planes[4].b = Matrix._24 - Matrix._22;
m_Planes[4].c = Matrix._34 - Matrix._32;
m_Planes[4].d = Matrix._44 - Matrix._42;
D3DXPlaneNormalize(&m_Planes[4], &m_Planes[4]);
m_Planes[5].a = Matrix._14 + Matrix._12; // plano de abajo
m_Planes[5].b = Matrix._24 + Matrix._22;
m_Planes[5].c = Matrix._34 + Matrix._32;
m_Planes[5].d = Matrix._44 + Matrix._42;
D3DXPlaneNormalize(&m_Planes[5], &m_Planes[5]);
ah, claro y como sabes tu las componentes de la matriz q tiene q sumar y restar para sacar la ecuacion del plano? a eso me referia.
saludos
muy simple, lo leí en un libro xDDDDD
qué libro? ;PP
saludos
Libros rulez.
Programming Role Playing Games in DirectX 8, de Premier Press
enrrollate y scanea ese par de hojas donde lo explica :oops: :oops: :oops: :oops: :oops: :oops: :X9: :X9:
aix.. si yo tuviera scanner. ..
he estado leyendolo bien y sólo explica que es el frustum, para que sirve y como se obtiene, pero nada de porqué se obtiene de esa forma, que es lo que ethernet quiere saber, no?
eso quiero saber entre otras cosas XXDD
A ver si
éste satisface tus necesidades, ethernet :ojo:
Yo os recomiendo GAME PROGRAMMING GEMS (hay 1,2 y 3). No me acuerdo de la ed. ni nada , pero me mola ese libro.
Que alguien se lo curro y lo escanee, :X9: :X9: :X9: :X9:
...hombre nose seran 3 o 4 hojas de explicación... tampoco creo que sean 20.
Enga.
:ojo: :ojo: :ojo:
Bueno, yo no e escaneado ningun libro pero tengo aqui un .pdf que esta bastante bien, como no recuerdo la dire os lo pongo aqui:
http://enigsoft.en.eresmas.com/fustrum.pdfpuede parecer algo complicado pero en los apendices podreis encontrar la implementacion, tanto para OpenGL como para Direct3D.
Saludos.
No va el link... ni siquiera poniendo frustum ;)
Jope!! que fallo de tonto muy tonto que he tenido...
probar este:
http://enigsoft.en.eresmas.com/FUSTRUM.pdf
anda! no se me ocurrio ponerlo en mayuscula. Este si rula! gracias :)
Muchas gracias _Grey. :)
Varios temas mas... ...no se si poner un nuevo post. Vosotros opinareis, si creeis que debe estar como nuevo topic.
Referente al frustrum culling ,quiero decir varias cosas. Siempre que miro revistas hablan de targetas que hacen la ostia poligonos por segundo. Weno, yo tengo un p4 512DDR con un Riva TnT2 32MB, ok.. ...pues pq si cojo y dibujo 1000 triangulos en pantalla a 1024x768, posicionados aleatoriamente ( sin texturas, ni nada ), ma bajan los frames hasta 20 o menos. Pq cuando utilizo el Frustrum Culling solo gano 2 frames, en teoria deberia ganar muchisismos, puesto que = solo paso al render 100 de los 1000. En cambio si me alejo bastante y dibujo todos los triangulos mejoro ostensiblemente el rendimiento, tiene menos superficie para dubujar. En culaquier caso creo que hay algo que se me escapa.
Otra Cosa. ¿ No os parece que necistariamos algun server donde almacenar la información que vamos recopilando ? Docs, páginas interesantes, etc, etc
No se desde el punto de vista legal de copyrigths si es viable el tema para Stratos. Pero estaria bien que se hiciera, no con el animo de plagiar, si no el de aprender. Por ejemplo, que opinamos que el tutorial de NeHe de cargar un MOD esta mu bien... ...Ok... pues nos lo descargamos lo comentamos lo intentamos mejorar y lo guardamos en un sever, de forma que tengamos acceso a todo esto. Evidentemente ofreciendo a quien acceda al server para descargase algo, la funte de donde fue extraida.
Incluso podriamos hacer CD's descargables, vamos como la MSDN, pero de programacion 3d. Creo que si ordenamos la informacion, sera mas rápido que quien quiera aprender aprenda.
A ver que os parece. Solo son ideas.
Gracias.
Me parece un gran idea :D :D :D :D
Citar
Pq cuando utilizo el Frustrum Culling solo gano 2 frames, en teoria deberia ganar muchisismos, puesto que = solo paso al render 100 de los 1000.
Bueno, eso depende de la técnica que uses para el frustrum culling :) te cuento mi experiencia:
Experimentando con height maps se me ocurrio la brillante idea de probar hasta donde podia llegar la potencia de mi recien adquirida GF4 ti4200. Pues me hice un algoritmo que hacia render "a saco" de toda la malla con display lists y otro que usaba frustrum culling chequeando triángulo por triángulo si estaba o no dentro del frustrum. Aqui tienes los resultados:
Display lists(a saco) Frustrum Culling
Malla 100x100 (20mil triangulos):75-80 fps 40-45 fps
Malla 200x200 (80mil triangulos):75-80 fps 10 fps
Malla 300x300 (180mil triangulos):70-75 fps 1-5 fps
Malla 400x400 (320mil triangulos):45-55 fps XXX
Malla 500x500 (500mil triangulos):35-40 fps XXX
Malla 600x600 (720mil triangulos):25 fps XXX
Como puedes ver, a mi algoritmo de frustrum culling le falta bastante por pulir :)
Jeje, ese PDF es el mismo que puse yo 4 posts más arriba... :loco:
Eso te pasa por ponerlo escondido. :jaja:
Repoker... Cuando hablas de Display List te refieres a utilizar glGenLists,glCallLists... etc o bien a utilizar VERTEX_ARRAYS.
l=glGenLists (1);
glNewList (l,GL_COMPILE);
glBegin(GL_TRIANGLES);
for (i=0;i {
glColor3ub (rgb[0],rgb[1],rgb[2]);
glVertex3f (xyz[0],xyz[1],xyz[2]);
glVertex3f (xyz[0]-5,xyz[1]-5,xyz[2]);
glVertex3f (xyz[0]+5,xyz[1]-5,xyz[2]);
}
glEnd();
glEndList();
y despues lo llamo a glCallList (l); desde la funcion del render... ...pues bien no gano frames LOS PIERDO!!! AGHHHH!!!
P.D: De todas formas... ...con 1000 triangulos 20 frames ? tan mala es la Riva TNT 2 ?
joder repoker, checkear cada triangulo con el frustum...
normalmente se divide la malla (octrees,etc) y entonces compruebas cada cubo-division, que puede contener que se yo, 500 polys...
evidentemetne, si compruebas cada triangulo, lo que ganas de render lo pierdes muchisimo mas por cpu
¿Cada uno de esos cuadros del octree debería ser un display list?
Lo digo pq se ganaría velocidad pero implicaría que los mapas fueran estáticos... es decir, no podríamos hacer que las montañas crecieran... o se generara un hueco al estilo worms. Depende de que tipo de juego quieras hacer.
¿Cómo lo haceis vosotros?
Otra pregunta:
¿La única forma de aprovechar el T&L con OpenGL es usar display list? ¿Hay otros métodos?
hola a tod@s, hacia bastante que no posteaba al foro O:)
sobre lo del frustum culling, primero lo de que bajen o suban los FPS no es del todo cierto, DirectX ya hace por si solo frustum culling, solo renderea lo que ve la camara, por supuesto. Asi que te da lo mismo decirle que pinte 100 que 1000 porque la diferencia va a ser poca.
Ahora, el furstum culling si que te va a dar mas velocidad a la hora de trabajar con tu escena. Todos los poligonos, objetos, etc que no esten en el frustum culling no hace falta que los actualices cada frame, ni mires colisiones, ni por supuesto mandarlos a renderizar.
como calcularlo, el post que he visto antes creo que lo explicaba, pero no lo he mirado bien, si eso envio yo mi codigo.
Basicamente creas un cubo normalito de 1x1, y le aplicas una matriz resultante de multiplicar la vista y la proyeccion. Vista para orientar el cubo hacia donde mire la camara, y proyeccion para hacerlo en 3D, el cubo original se transformara en una piramide donde la punta esta justo donde estas tu, y la base en el horizonte, alla donde este el limite de lo que dibujas. Una vez calculado este cubo, creas 6 planos (arriba, abajo, derecha, izquierda, cerca, lejos) (puedes crear un plano a partir de 3 puntos, asi que coge cualquiera de los 4 puntos de cada cara del cubo para ello) y despues para saber si algo esta dentro o fuera del cubo calculas la distancia desde el centro del objeto a cada uno de los planos, segun si es positivo o negativo estara a un lado del plano o al otro. En el momento que este test falle para cualquiera de los planos el objeto esta fuera del frustum.
basicamente este es el proceso, hay muchos tutoriales que explican esto pero casi todos son para OpenGL, no he encontrado nada para DirectX.
mira en gamedev.net que hay varios articulos sobre esto. :)
En cuanto a los libros, los de Game Programming Gems (corregirme sino) creo que ninguno habla del frustum culling, pero los de Game programming series hay uno que si:
http://www.amazon.co.uk/exec/obidos/ASIN/1...8703436-8406836te puedo enviar codigo fuente si quieres sobre frustum culling y octree pero son en OpenGL.
salu2
OpenGL Roolz... Corday UK
pero pq me bajan los frames cuando utilizo Display Lists ?
lo de las display list no lo se muy bien, no controlo mucho el OpenGL la verdad.
pero puede ser porque chequeads si cada vertice esta en el frustum, en vez de ello utiliza simplemente una bounding sphere, asi solo compruebas un punto y el radio. Para el terrreno no puedes usar bounding sphere, pero si octree. el centro del cubo te puede servir tambien para mirar si un nodo esta o no dentro del frustum.
Yo en concreto no me preocupo de dividir cada nodo con el frustum culling etc, con tal de que este un poquito dentro del frustum ya lo rendereo, la diferencia no es mucha. :)
general sobre frustum culling
http://www.gamedev.net/reference/programmi...atures/culling/codigo fuente frustum culling en OpenGL
http://www.gametutorials.com/download/Open...Culling_OGL.zip
Mis esperiencias son de DirectX no de OpenGL que hace tiempo que no lo toco, pero si os puedo contar que a mi tambien me perdia fps usando el frustum culling, pero la cuestion es saber como usarlo.
Evidentemente calcular poligono por poligono es un gran error, hay que dividir el gran objeto que es el escenario en trozos "de tamaño moderado", si usas distintos vertexbuffer (hablo de DirectX) tambien perderas tiempo tontamente, cuando se trata de un objeto como un personaje, nada de dividirlo en trozos, calculas todo ese objeto si esta o no dentro de la vista (aqui si que ganareis tiempo,seguramente).
Whoiam , como ya e dicho hace tiempo que no toco OpenGL pero parece que la gente hoy en dia le da mas a los VERTEX_ARRAY que a las listas, en fin si algien lo puede comfirmar.........?
Loover , cuando tienes T&L siempre se usa, es decir envias el vertice y OpenGL lo pasa por la matriz de mundo y las que haga falta, indistintamente de usar listas o no, pero usando listas o VERTEX_ARRAY le pasas los vartices mas rapidamente que haciendo un bucle con un monton de glVertexXX(), pero cuando lo trasforme por las matrizes de mundo y todas las demas usara T&L................... a no ser que este desactivado,claro.
CordayUK ,lo de que DirectX hace frustum culling por si solo es una afirmacion gratuita, evidentemente no pinta los poligonos que estan fuera de la camara, pero nada mas.Las colisiones y demas cosas se tienen que seguir calculando aun que no salgan por el frustum, aun que no se vea "el malo siguira moviendo".
BeRSeRKeR , no te estrañe que me dieras tu mismo la url de ese .pdf, pero no se cual es y no lo encuentro, por eso lo e colgado por ahi.
Saludos.
te doy la razon, he sido un poco bestia al decir que el directx ya hace frustum culling por si mismo :)
lo que queria decir es que al final no va a renderear mas que lo que ve la camara, la velocidad se gana no en que no tenga que "renderear" literalmente los objetos, sino en que ni siquiera los mandas a renderear.
Whoiam:
Repoker... Cuando hablas de Display List te refieres a utilizar glGenLists,glCallLists... etc o bien a utilizar VERTEX_ARRAYS.
Me refiero a lo primero, genlist y luego callList.
Colson:
joder repoker, checkear cada triangulo con el frustum...
Ya ya coño XD no tengo implementado ningun algoritmo para reducir el nº de triangulos a chequear, tenia pensado usar quadtrees o octrees :P pero todavia no lo tengo hecho.
Arras !
pues joder, a mi las Display List no me mejoran el rendimiento :( :( :(
y a ti el rendimiento es bestial cuando le pones listas :( :( :(
vaya kk
¿Whoiam la prueba la hiciste con un único triángulo o con pocos? Para que se aprecie una mejora deben ser muchos los que mandes a la tarjeta. Prueba a renderizar una fase completa del quake 3 por ejemplo... la diferencia es casi del doble de fps
Otra cosa, leo muchas veces que el glDrawElements es más rapido que mucha ordenes glvertexf... eso es cierto SOLO cuando estan fuera de un display list. Si las utilizas dentro de un display list se renderizarán ambas igual de rápidas, porque ya pasarán a otra estructura bien diferente almacenada a ser posible en la memoria de la tarjeta.
Grey_:
No estoy seguro de lo que dices del T&L, lei hace tiempo en un foro en ingles... lo he vuelto a buscar pero no lo encuentro... gente que preguntaba como explotar el T&L de las tarjetas actuales en OpenGL; y no se cansaban de repetir que usando display lists y que no se podía desactivar.
Citarpues joder, a mi las Display List no me mejoran el rendimiento :( :( :(
y a ti el rendimiento es bestial cuando le pones listas :( :( :(
Bueno, parece muy bestia porque la otra manera (frustrum) esta mal hecha. En realidad no es tanta la diferencia, si hago una comparación entre display lists y normal (gltriangle etc.) ya posteare ..
En constestación a CordayUK:
Es cierto que finalmente tanto DirectX como OpenGL realizan un clipping de la escena. Sin embargo para ganar velocidad lo mejor es eliminar la renderización del vértice lo mas tempranamente posible del pipeline.
Es decir, el clipeo y escalado se realiza al final de este pipeline, pero antes multiplicaste cada vértice por las tres matrices (de mundo, de vista y de proyección), hay que tratar de procesar la menor cantidad de vértices que finalmente no se renderizarán.
Es díficil que esto lo implemente una librería como DirectX y OpenGL ya que quien tiene conocimiento del dominio del problema es el programador y no la librería. Tú a lo mejor sabes que cierto objeto no es necesario dibujarlo en un determinado momento pero DX no lo sabrá hasta no incorporarlo y proyectarlo al mundo con el mismo tipo de coordenadas que el resto de los objetos.
El en **** clavo tio.
tienes razon. que carajo! :D
mmm para el frustrum culling utilizo una funcion que le paso 1 punto (xyz) y me determina si ese punto se encuentra dentro del frustrum...
Por consiguiente, si tengo triangulos en mi escena le paso los vertices de los tres triangulos y si con esa funcion me dice que hay alguno dentro, dibujo el rectangulo.
...pero puede darse la circumstancia que tenga en pantalla... :-?
alguna idea :idea: :idea: :idea:
para que el triangulo este fuera del frustum todos los vertices han de estar fuera pero al mismo lado del plano del frustum, en el caso que tu dices cada uno tiene diferente signo no?
mi funcion solo devuelve true o false... :(
voy a cambiar e implementar una que me diga por que lado ha salido fuera. ;) asias.