vertical - swing fillers java

Idea de implementación 3D Shadow

Question

Supongamos que su ojo está en el punto de superficie P1 en un objeto A y hay un objeto de destino B y hay una fuente de luz de punto detrás del objeto B.

Pregunta: ¿ estoy en lo cierto si miro hacia la fuente de luz y digo "estoy en una sombra" si no puedo ver la luz debido al objeto B? Luego señalo ese punto del objeto A como "uno de los puntos de sombra de B sobre A".

Si esto es cierto, ¿podemos construir un objeto de "geometría de sombra" (negro) en la superficie de A y luego cambiarlo constantemente debido al movimiento de la luz, B, A, etc. ... en tiempo real ? Digamos que una esfera (A) tiene 1000 vértices y otra esfera (B) también tiene 1000 vértices, ¿esto significa comparaciones de 1 millón? (¿está sombreando, O (N ^ 2) (tiempo) complejidad?). No estoy seguro acerca de la complejidad porque el cambio de P1 (ojo) también cambia el punto visto de B (entre P1 y el punto de la fuente de luz). ¿Qué pasa con las sombras de segundo orden y las más altas (como las luces que se reflejan entre dos objetos muchas veces)?

Estoy usando Java-3D ahora, pero no tiene capacidades de sombra así que pienso en moverme a otras bibliotecas compatibles con Java.

Gracias.

Edición: necesito deshabilitar la "cámara" cuando muevo la cámara para construir esa sombra. ¿Cómo puedo hacer esto? ¿Esto disminuye el rendimiento mal?

Nueva idea: java3D tiene detección de colisión incorporada. Crearé líneas (invisibles) de polígono-vértice de luz a blanco y luego verificaré si hay una colisión de otro objeto. Si se produce una colisión, agrega ese vértice corrd. a la lista de sombras, pero esto solo funcionaría para las luces de posición :(.

Cualquiera que suministre una biblioteca de sombra real para java3d, será de mucha ayuda.

Una muestra muy pequeña de Geomlib shadow / raytracing en java3D sería el mejor ejemplo de rastreo de rayos tal vez?

Sé que esto es un poco difícil, pero podría haber sido probado por al menos un centenar de personas.

Gracias.

Answer 1

Básicamente sí, tu enfoque producirá sombras. Pero hacerlo punto por punto no es factible en cuanto al rendimiento (en tiempo real), a menos que se haga en la GPU. No estoy familiarizado con lo que ofrece la API hoy, pero estoy seguro de que cualquier motor reciente ofrecerá una sombra fuera de la caja.

Su ''Nueva idea'' es cómo se implementaron las sombras en los días en que el renderizado aún se realizaba con la CPU. Si el número de polígonos no es demasiado grande (o puede rechazar eficientemente racimos enteros al tener volúmenes de agrupación, etc.), se puede hacer con bastante poca potencia de CPU.

Answer 2

La representación de sombras 3D en Java vainilla nunca va a ser eficiente. Lo mejor es utilizar las bibliotecas gráficas escritas para utilizar el rango completo de capacidades de la tarjeta gráfica, como OpenGL o DirectX. Al usar Canvas (de la captura de pantalla que proporcionó), incluso puede pintar ese Canvas desde código nativo utilizando JNI. De modo que podría usar toda la tecnología de las bibliotecas gráficas, hacer un poco de toqueteo y pintar su Lienzo directamente desde el código nativo. Habría muy poco trabajo para que funcione, en comparación con escribir su propio motor 3D.

Enlace Wiki sobre acceso nativo AWT: http://en.wikipedia.org/wiki/Java_AWT_Native_Interface Documentation: http://docs.oracle.com/javase/7/docs/technotes/guides/awt/AWT_Native_Interface.html

Answer 3

Su enfoque se puede resumir así:

foreach (point p to be shaded) {
    foreach (light) {
        if (light is visible from p)
            // p is lit by that light
        else
            // p is in shadow
    }
}

Lo gracioso es que así se hacen las sombras en tiempo real en la GPU .

Sin embargo, no es trivial para que esto funcione de manera eficiente. La representación de la escena es un proceso simplificado, triángulo por triángulo. Sería muy engorroso si por cada punto (píxel, fragmento) en cada triángulo hubiera que considerar todos los demás triángulos para verificar la intersección de los rayos.

Entonces, ¿cómo hacer eso de manera eficiente? Respuesta: invierte el proceso.

Hay muchas menos luces que píxeles en la escena, por lo general. Aprovechemos este hecho y preprocesamos un poco:

// preprocess
foreach (light) {
    // find all pixels p on the scene reachable from the light
}
// then render the whole scene...
foreach (point p to be shaded) {
    foreach (light) {
        // simply look up into what was calculated before...
        if (p is visible by the light)
            // p is lit
        else
            // p is in shadow
    }
 }

Eso parece mucho más rápido ... Pero quedan dos problemas:

1. cómo encontrar todos los píxeles visibles por la luz?
2. cómo hacer que sean accesibles rápidamente para la búsqueda durante el procesamiento?

Ahí está la parte difícil:

• ¡Para encontrar todos los puntos visibles por una luz, coloque una cámara allí y renderice toda la escena! La prueba de profundidad rechazará los puntos invisibles.
• Para hacer que este resultado sea accesible más tarde, guárdelo como una textura y use esa textura para buscar durante la etapa de representación real.

Esta técnica se denomina Asignación de sombras , y la textura con píxeles visibles desde una luz se denomina Mapa de sombras. Para una explicación más detallada, vea por ejemplo el artículo de Wikipedia .

Answer 4

Las sombras son probablemente el tema más complejo en la programación de gráficos 3D, y existen muchos enfoques, pero la mejor opción debe identificarse según los requisitos de la tarea. El algoritmo del que está hablando es la forma más sencilla de implementar las sombras de una fuente de luz puntual en el plano. No debe hacerse en la CPU, ya que usted usa la GPU para renderizar en 3D.

Básicamente, el enfoque consiste en representar el mismo objeto dos veces: una desde el punto de vista de la cámara y otra desde el punto de la fuente de luz. Tendrá que preparar matrices de vista modelo para convertir entre estas dos vistas. Una vez que renderizas el objeto desde el punto de luz, obtienes el mapa de profundidad, en el que cada punto se encuentra más cerca de la fuente de luz. Luego, para cada píxel de la representación normal, debe convertir sus coordenadas tridimensionales en la vista anterior, y compararlas con el valor de profundidad correspondiente. Esto esencialmente le brinda una manera de saber qué píxeles están cubiertos por la sombra.

El impacto en el rendimiento proviene de representar el mismo objeto dos veces. Si su tarea no supone una alta escalabilidad de la solución de shadow casting, entonces podría ser un camino por recorrer.

Una cantidad de preguntas relevantes:

¿Cómo creo sombras baratas en OpenGL?

¿Hay alguna manera fácil de obtener sombras en OpenGL?

¿Cuál es el método más simple para renderizar sombras en una escena en OpenGL?