Ir al contenido

publicidad

Foto

¿Cómo mover 1.000.000 de vertex y no morir en el intento?


Este tema ha sido archivado. Esto significa que no puedes responder en este tema.
9 respuestas en este tema

  • Ollydbg

  • Jockey

  • vida restante: 100%
  • Registrado: 05 sep 2008
  • Mensajes: 6.259
#1

Escrito 02 diciembre 2008 - 21:08

Pues esa es la pregunta del millón de dolares.

¿Alguien sabe de un buen how-to que únicamente se centre en este aspecto?

La mayoría de los engines que publican el código fuente tienen tropecientasmil clases (lógico por otra parte, ya que son engines completos) y entre tal cantidad de información no saco nada en claro.

Sé que desde DirectX, usando una caracterisitica de aquellas tarjetas DirectX nativas para la versión 9 se puede hacer "oclusión" de objetos, pero mi idea es hacerlo independientemente, ya que no descarto usar OpenGL.

He leído algo sobre "portales", sobre "bsp", sobre "octrees", pero sigo sin verlo claro.

Cualquier ayuda será bien recibida

PD: tanto el idioma del how-to me es indiferente (bueno, si está en chino o en japones no X-D) y el lenguaje de programación también (C, C#, Python, .Net, Delphi, etc)

Saludos.

  • Ellolo17

  • Heraldo de la Muerte

  • vida restante: 100%
  • Registrado: 16 nov 2006
  • Mensajes: 6.208
#2

Escrito 02 diciembre 2008 - 21:27

O sea: Que te quieres hacer un motor grafico con esa capacidad o quieres que tu motor grafico lo haga a un framerate decente?

Yo por mi experiencia hice una prueba en el DarkBasic. Que mientras el framerate sea superior a 30 cree una esfera en una posicion aleatoria para que al llegar a 30 saber las esferas y los poligonos que hay -un poligono = 3 vertex-

El resultado si no recuerdo mal en mi portatil era de 450.000 poligonos. Eso son 1.350.000 vertices mas o menos.

El portatil donde hice la prueba es in core 2 duo de 2,5 ghz con una ati movility radeon x 2300 de 1405 MB con 3 GB de ram.

Asi que si es que si un motor grafico puede moverlo, puede. Si el pc es peor, pues le costará mas... pero poder lo puede hacer.

Pero si te estas haciendo / modificando un motor, ahi no puedo ayudarte... Lo siento.

Un saludo.

  • Ollydbg

  • Jockey

  • vida restante: 100%
  • Registrado: 05 sep 2008
  • Mensajes: 6.259
#3

Escrito 02 diciembre 2008 - 21:47

O sea: Que te quieres hacer un motor grafico con esa capacidad o quieres que tu motor grafico lo haga a un framerate decente.


Ambas cosas ;)

Veamos, imagina que me creo una "escena" en el blender, o en 3d studio, que contiene tal cantidad de polígonos / vertices (habría que ver como cargo esos datos en memoria, ya bien leyendo directamente del *.3ds, o parseando un fichero XML con todos los datos de la escena, o lo que sea, eso no me preocupa demasiado).
La cuestión es que si intento mover dicha escena con 1.000.000 de vertices, ya puedo tener 200 HD4870X2 en Crossfire o 200 GTX260 en SLI que la tasa de FPS sería ridícula.

De ahí mi necesidad de utilizar alguna técnica de "oclusión" (ya sean portales, bounding spheres, octrees o lo que sea)

Y sí, el engine me lo quiero hacer yo desde 0 (seamos realistas, no quiero hacer nada espectacular), para poder tener control total sobre lo que haga (no uso engines tipo OGRE 3D, o tipo Irrlicht Engine, etc porque son demasiado potentes para la ridiculez que pretendo hacer).

Saludos.

  • Ellolo17

  • Heraldo de la Muerte

  • vida restante: 100%
  • Registrado: 16 nov 2006
  • Mensajes: 6.208
#4

Escrito 02 diciembre 2008 - 23:08

Mmmm... Pues poco voy a poder ayudarte...

Supongo que un buen metodo es no hacer un array muy grande para almacenar por cada vertice su posicion.... Recorrerse el array ese entero es mucha carga para el ordenador sea el que sea como dices.

Asi que te recomiendo que dividas -Vamos, que en vez de hacer un array gigantesco con todos los datos de los vertices, intentes dividir en arrays que muevan una decima parte. Y estos a su vez en otros y asi hasta que llegues a lo mas cercano posible a la unidad-

Con esto me refiero. En vez de un array de 1.000.000 de huecos, create 10 de 10 huecos que se repartan la carga.

Esos que contengan a su vez los datos de otros 10 grupos.

Y asi sucesivamente.

Entonces para calcular la posicion pasas mas carga a la memoria y menos a la cpu ya que en vez de recorrerse todo el array y actualizar podria ir administrandolos por grupos.

Mas o menos, no se si se me entiende.

Si haces un:

For i = 0 to i=numero_vertices_modelo step 1
actualiza_modelo(espada.3ds, i)
next i
actualiza_modelo(modelo, vertice)
modelo.vertice(vertice).posicion x = modelo.vertice(vertice).posicion x +1
endfunction

Supongo que algo similar es lo que intentas.

Yo opino que si en vez de tratar asi el modelo lo haces como:

while cont < total_vertices_modelo

endwhile


Bah, estoy desvariando. Que yo no se de eso.

Pero se que muchos de estos motores tratan mucho con los bits (los clasicos operadores >> y << )

Lamento no ser de mas ayuda.
Un saludo.

  • Ollydbg

  • Jockey

  • vida restante: 100%
  • Registrado: 05 sep 2008
  • Mensajes: 6.259
#5

Escrito 02 diciembre 2008 - 23:54

Juer tio, pues para no tener ni idea, no vas mal encaminado, no , jejeje ;)

Lo que comentas de los grupos es lo que se conoce como árboles de partición binaria del espacio (o su acrónimo ingles BSP Trees). En esencia es exáctamente lo que tú indicas. Además, un algoritmo BSP "eficiente" intenta que las ramás tengan una "carga" similar de "hijos"...pfff...aquí se requiere una imagen, ya que vale más que mil palabras:

Imagen Enviada

En el caso del gráfico, se ha divido el "plano" en 4 sectores (sector 1, 2, 3 y 4). Los círculos representan "polígonos". Cómo ves en el gráfico del "árbol", si dibujo la "hoja" 2, solo dibujaré los polígonos "B" y "C", omitiendo (y ganando tiempo de proceso) el resto de polígonos.


Esta es una técnica (tal y cómo ya dije antes). Aunque existen otras, como el caso de los octrees, que es un "refinamiento" del algoritmo de los BSP Trees, QuadTrees, También hay el uso de portales (básicamente, se usan dos frustums, uno para renderizar la escena y otro para delimitar que es lo que se renderiza en el primer frustum).

En el caso de los octrees se divide la escena hasta la "unidad", o en si defecto, hasta que no pueda dividirse más veces.
(ejemplo gráfico aclaratorio)
Imagen Enviada

La teoría es "fácil"...pero ¿Cómo implemtar esto?...ni flowers X-D

Por cierto, gracias por el interés Ellolo17.

Saludos.

#6

Escrito 03 diciembre 2008 - 00:13

El octree vendria a ser un árbol de 8 hijos? porque me suena a eso

  • Ellolo17

  • Heraldo de la Muerte

  • vida restante: 100%
  • Registrado: 16 nov 2006
  • Mensajes: 6.208
#7

Escrito 03 diciembre 2008 - 13:55

Buf, pues la verdad que solte lo primero que se me ocurrio como posible solucion. Ni idea de que fuese uno de los metodos XD

Mmm.... Te recomiendo una cosilla: Puedes coger el Ogre, abrir los archivos que se dedican solamente al renderizado o a mover los poligonos y tal, entenderlos, copiarlos y pegarlos en tu aplicacion y asi aprendes como lo hacen ellos y luego si eso puedes adaptarlo, o usar tus recien adquiridos conceptos para darle leña al mono.

O buscar tutoriales por internet sobre el tema pero viendo que estas preguntando aqui supongo que no habrá o esta muy escondido...

Un saludo.

    caleb_blo

  • CANCELADO
  • Registrado: 25 feb 2001
  • Mensajes: 4.918
#8

Escrito 03 diciembre 2008 - 17:22

Puedo ayudarte en ese tema, te mando un privado.

    paliyoes

  • EXPULSADO
  • vida restante: 0%
  • Registrado: 23 mar 2002
  • Mensajes: 12.568
#9

Escrito 13 diciembre 2008 - 16:05

Puedo ayudarte en ese tema, te mando un privado.


¿No sería mejor que escribieras aquí lo que le digas para que cualquier lector del foro aprenda?

  • galletone

  • Saitama

  • vida restante: 100%
  • Registrado: 28 ene 2004
  • Mensajes: 5.431
#10

Escrito 14 diciembre 2008 - 00:32

A ver, si no entiendo mal pretendeis mover 1.000.000 de vertices asi por la jeta desde un array con un bucle for guarro ¿no? Si es asi os dire que asi NO se consigue en la vida. Para poder mover semejante cantidad de vertices hay que emplear funcionalidades propias de directx y opengl. Por ejemplo para hacer esto en directx se deben meter los vertices en un vertex buffer. ¿Y que es esto? pues no es mas que una abstraccion software que proporciona directx para que el driver de la grafica envie los datos de los vertices a memoria de video para que la gpu los trate directamente y a toda ostia. Asi veras como da gloria verlo andar.

Esto que comento seria la primitiva mas basica, luego combinado con tecnica de portales, bounding spheres, octrees, arboles bsp y demas se consigue multiplicar el rendimiento.


Este tema ha sido archivado. Esto significa que no puedes responder en este tema.
publicidad