OpenGL- Método simple de clipping/oclusión 2D?

Question

Estoy trabajando en una versión parcial de juego relativamente pequeña (vista superior) del juego, utilizando OpenGL para mis gráficos. Se trata de un ángulo basado en el sigilo básico, y como tal con todos mis enemigos estoy dibujando un arco de visión para que el jugador sepa dónde están mirando.

Uno de mis problemas hasta ahora es que cuando dibujo este arco la vista (como un polígono relleno) se muestra de forma natural a través de las paredes de la pantalla ya que no hay nada que impida que:

http://tinyurl.com/43y4o5z

I' Tengo curiosidad por saber cómo puedo prevenir algo como esto. Ya tengo un código en su lugar que me permitirá detectar intersecciones de línea con muros y demás (para la detección de la vista del enemigo), y teóricamente podría usar esto para detectar un caso así y dibujar el polígono en consecuencia, pero esto probablemente sería bastante complicado y/o ineficiente, entonces me pregunto si hay algún sistema OpenGL integrado que pueda hacer esto para mí, probablemente lo haría mucho mejor.

He intentado buscar preguntas sobre temas como saturación/oclusión, pero ni siquiera estoy seguro de si esto es exactamente lo que debería estar buscando; mis habilidades OpenGL son limitadas. Parece que cualquier cosa que use, digamos, glClipPlanes o glScissor no sería adecuada para esto debido a la gran cantidad de muros individuales y demás.

Por último, esto es solo una demostración que estoy haciendo en mi tiempo libre, por lo que los gráficos no son exactamente mi principal preocupación. Si hay una manera (razonablemente) indolora de hacer esto, entonces espero que alguien pueda señalarme en la dirección correcta; si no hay una manera simple, entonces puedo dejar el problema por ahora o encontrar otras soluciones.

Answer 1

Esto es esencialmente un problema de sombreado. He aquí cómo lo haré:

Para cada punto alrededor del borde de su arco, trace un rayo (2D) desde el enemigo hacia el punto, buscando intersecciones con los cuadros verdes. Si los cuadros verdes siempre van a estar alineados con el eje, la matemática será mucho más fácil (busque la intersección Ray-AABB). Representar los puntos de intersección como un abanico de triángulos le dará su arco.

Como mencionas que ya tienes el código de intersección línea a pared, entonces mientras eso te diga la distancia desde el enemigo hasta la pared, entonces podrás usarlo para el arco visual. No asuma automáticamente que será demasiado lento: ya no estamos funcionando con 486s. Siempre puede reducir el número de puntos alrededor del borde de su arco para acelerar las cosas.

Answer 2

El manejo de oclusión incorporado de OpenGL está diseñado para tareas 3D y no se me ocurre una forma sencilla de manipularlo para lograr el efecto deseado. Si fuera yo, la forma en que lo resolvería es usar un programa de sombreador de fragmentos, pero prevenga que esto definitivamente no cae bajo "una forma (razonablemente) indolora de hacer esto". Brevemente, primero renderiza un "mapa de oclusión" binario que es negro donde hay paredes y blanco en caso contrario. Luego renderiza el "arco de visualización" como lo hace actualmente con un programa de fragmentos diseñado para buscar desde el visor hacia la ubicación de destino, buscando un oclusor (píxel negro). Si encuentra un oclusor, representa ese píxel del "arco de visión" como 100% transparente. Sin embargo, en general, si bien esta es una solución "correcta", definitivamente diría que esta es una función compleja y parece estar bien sin implementarla.

Answer 3

Me imagino que si hay algún sistema OpenGL integrado que pueda hacer esto para mí probablemente lo haría mucho mejor.

OpenGL es una API de dibujo, no una biblioteca de procesamiento de geometría.

En realidad, su método de prueba de intersección es la forma correcta de hacerlo. Sin embargo, para acelerarlo, debe usar una estructura de subdivisión espacial. En su caso, tiene algo que llora por un árbol de particiones binarias . Los árboles BSP tienen una buena propiedad, la complejidad para encontrar intersecciones de una línea con paredes es en promedio O (log n) y el peor caso es O (n log n), o en otras palabras, BSP tress son muy eficiente. Vea las preguntas más frecuentes de BSP para más detalles http://www.opengl.org//resources/code/samples/bspfaq/index.html