Representar Un Plano Infinito

[senior wapo]

 ¿ Alguien conoce el algoritmo o un enlace con la forma más eficiente de representar en pantalla un plano infinito ? En el peor de los casos usaría 3 triangulos (horizonte cruzando dos planos de frutum contiguos) o 2 triangulos si el horizonte va de lado a lado de la pantalla.

Pienso que tiene que haber algun método que no pase por calcular la intersección con los 6 planos del frustum.

[BeRSeRKeR]

 No sé si esto te servirá, pero es lo que utilizo para renderizar el frustum de las cámaras y las spot lights en world-space.

Primero defino los vértices del frustum en clip-space, es decir, tendría:

Código [Seleccionar] Expand

vertices[0] = new CustomVertex.PositionOnly(-1.0f, 1.0f, -1.0f);        // Vértice de la esquina superior-izquierda -Z
vertices[1] = new CustomVertex.PositionOnly( 1.0f, 1.0f, -1.0f);        // Vértice de la esquina superior-derecha -Z
vertices[2] = new CustomVertex.PositionOnly( 1.0f, -1.0f, -1.0f);        // Vértice de la esquina inferior-derecha -Z
vertices[3] = new CustomVertex.PositionOnly(-1.0f, -1.0f, -1.0f);        // Vértice de la esquina inferior-izquierda -Z

vertices[4] = new CustomVertex.PositionOnly(-1.0f, 1.0f,  1.0f);        // Vértice de la esquina superior-izquierda +Z
vertices[5] = new CustomVertex.PositionOnly( 1.0f, 1.0f,  1.0f);        // Vértice de la esquina superior-derecha +Z
vertices[6] = new CustomVertex.PositionOnly( 1.0f, -1.0f,  1.0f);        // Vértice de la esquina inferior-derecha +Z
vertices[7] = new CustomVertex.PositionOnly(-1.0f, -1.0f,  1.0f);        // Vértice de la esquina inferior-izquierda +Z

Después, en nuestro caso el frustum lo renderizamos con líneas por lo que especificamos los índices para definir las líneas que conforman el frustum.

Finalmente hay que pasar esos vértices a world-space. Esto se hace transformando los vértices por la matriz resultante de multiplicar la inversa de la matriz de proyección y la inversa de la matriz de vista (o simplemente la matriz de mundo de la cámara).

world_matrix = camera_inv_proj_matrix * camera_inv_view_matrix
ó
world_matrix = camera_inv_proj_matrix * camera_world_matrix

Transformados los vértices por dicha matriz ya los tienes en world-space. En el caso de un plano horizontal, bastaría con sustituir la componente Y por la altura a la que tú quieras que esté el plano y listo.

En teoría con eso tendrías un plano que tiene las dimensiones del frustum pero con la altura que tú le especifiques. Evidentemente puedes utilizar una combinación diferente de vértices para obtener un plano en XZ, XY, etc.

Hay que tener en cuenta que esto es para Direct3D que el clip-space se define como:

X € [-1, 1]
Y € [-1, 1]
Z € [-1, 1]

En el caso de OpenGL si no recuerdo mal es:

X € [-1, 1]
Y € [-1, 1]
Z € [0, 1]

Y bueno el orden de concatenación de las matrices debería ser el contrario que en Direct3D.

Tal vez no es lo que buscas pero a lo mejor te da ideas.

Saludos.

[Sacrifai]

 Um, ¿y si en vez de usar un plano infinito usas algo parecido a un sky box? Que se mueva el plano en relación a la camara.

[senior wapo]

 Gracias por currártelo Berserker. Realmente lo que yo buscaba es un plano arbitrario y representarlo en pantalla sin usar el tipico grid, sino con 2-3 triangulos, como hace Blitz3D.

Si pulsas 'W' (wireframe) en el juego que puse en el concurso, Kutron, verás que el suelo aparece siempre con 2 triangulos. En Blitz lo defino como un plano infinito paralelo al suelo, pero puede estar en cualquier posición y orientación en el espacio 3D.

Se me ocurre trabajar calculando la linea del horizonte en 2D (sobre la pantalla) y mirando a que lado queda el plano, reconstruir el poligono, cuyos lados coinciden con los bordes de pantalla necesariamente, salvo que haya clipping con el plano cercano (zNear). A partir de ahí aplicar las inversas de las matrices de transformación para hallar los puntos en worldspace.

La cosa es como derivar un algoritmo eficiente de eso, principalmente de la parte de calcular el horizonte.

Pero vamos, es curiosidad más que nada, no es que necesite el algoritmo para nada en concreto.