¿Por qué mi color desaparece cuando habilito la iluminación en OpenGL?

Question

Estoy desarrollando una aplicación de gráficos en C++ con OpenGL API y GLUT.

Para añadir la iluminación, he hecho los siguientes cambios en mi matriz modelview:

glEnable(GL_LIGHTING); 
glEnable(GL_LIGHT0); 

// Create light components. 
GLfloat ambientLight[] = { 0.2f, 0.2f, 0.2f, 1.0f }; 
GLfloat diffuseLight[] = { 0.8f, 0.8f, 0.8, 1.0f }; 
GLfloat specularLight[] = { 0.5f, 0.5f, 0.5f, 1.0f }; 
GLfloat position[] = { 0.0f, 0.0f, 0.0f, 1.0f }; 

// Assign created components to GL_LIGHT0. 
glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight); 
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight); 
glLightfv(GL_LIGHT0, GL_SPECULAR, specularLight); 
glLightfv(GL_LIGHT0, GL_POSITION, position); 

La iluminación funciona en gran medida creo, pero los colores de los objetos de mi todo desaparezca. Todo lo que veo es una silueta en blanco y negro de mi figura general.

Me preguntaba por qué es esto?

Answer 1

Cuando se activa la iluminación, un vértice' color no se determina a partir del color fijado por glColor o glColorPointer, sino por los colores materiales establecidos actualmente combinados con las luces colores utilizando los cálculos de iluminación.

Para cambiar el color de un objeto, debe cambiar la configuración del material (que por defecto es un material gris difuso) antes de renderizar, utilizando las funciones glMaterial. Hay esencialmente un color de material correspondiente para cada uno de los diferentes colores claros (GL_DIFFUSE, ...) junto con algunas propiedades adicionales para aproximar los materiales emisores de luz (GL_EMISSION) y controlar la rugosidad del material (GL_SHININESS). Lea algún material introductorio sobre las características de iluminación de OpenGL para comprender su funcionamiento.

Lo que puede hacer para adaptar rápidamente su código de la coloración normal a la iluminación (o para habilitar las propiedades del material por vértice) es usar material de color. Llamando al glEnable(GL_COLOR_MATERIAL) y configurando un mapeo apropiado con glColorMaterial puede configurar OpenGL para cambiar un color de material específico, siempre que cambie el color del vértice actual (usando glColor o glColorPointer).

Answer 2

Probar glEnable(GL_COLOR_MATERIAL).

Ver Common OpenGL Pitfall #14:

14. cuidadosa Habilitación de Color Material

función del material de color OpenGL proporciona una manera menos costosa de parámetros del material de cambio. Con material de color activado, los colores del material rastrean el color actual. Esto significa que en lugar de usar la rutina , relativamente costosa, glMaterialfv, puede usar la rutina glColor3f.

Aquí se muestra un ejemplo utilizando la función de material de color para cambiar el color difuso para cada vértice de un triángulo:

glColorMaterial(GL_FRONT, GL_DIFFUSE); 
glEnable(GL_COLOR_MATERIAL); 
glBegin(GL_TRIANGLES); 
    glColor3f(0.2, 0.5, 0.8); 
    glVertex3f(1.0, 0.0, 0.0); 
    glColor3f(0.3, 0.5, 0.6); 
    glVertex3f(0.0, 0.0, 0.0); 
    glColor3f(0.4, 0.2, 0.2); 
    glVertex3f(1.0, 1.0, 0.0); 
glEnd(); 

en cuenta la secuencia de código más caro necesario si glMaterialfv se utilizado explícitamente:

GLfloat d1[] = { 0.2, 0.5, 0.8, 1.0 }; 
GLfloat d2[] = { 0.3, 0.5, 0.6, 1.0 }; 
GLfloat d3[] = { 0.4, 0.2, 0.2, 1.0 }; 

glBegin(GL_TRIANGLES); 
    glMaterialfv(GL_FRONT,GL_DIFFUSE,d1); 
    glVertex3f(1.0, 0.0, 0.0); 
    glMaterialfv(GL_FRONT,GL_DIFFUSE,d2); 
    glVertex3f(0.0, 0.0, 0.0); 
    glMaterialfv(GL_FRONT,GL_DIFFUSE,d3); 
    glVertex3f(1.0, 1.0, 0.0); 
glEnd(); 

Si está renderizando objetos que requieren frecuentes cambios de material simple , intente utilizar el modo de material de color. Sin embargo, hay una falla común al habilitar el modo de material de color. Cuando el material de color está habilitado, OpenGL cambia inmediatamente los colores del material controlados por el estado del material de color. Considere la pieza de código siguiente para inicializar un contexto cree de nuevo OpenGL:

GLfloat a[] = { 0.1, 0.1, 0.1, 1.0 }; 
glColor4f(1.0, 1.0, 1.0, 1.0); 

glMaterialfv(GL_FRONT, GL_AMBIENT, a); 
glEnable(GL_COLOR_MATERIAL); /* WARNING: Ambient and diffuse material latch immediately to the current color. */ 
glColorMaterial(GL_FRONT, GL_DIFFUSE); 
glColor3f(0.3, 0.5, 0.6); 

¿En qué estado se el ambiente frente y colores material difuso será después ejecutar el fragmento de código anterior? Si bien el programador puede tener destinado a que el estado del material ambiente sea (0.1, 0.1, 0.1, 1.0) y , el estado del material difuso es (0.3, 0.5, 0.6, 1.0), que no es .

El estado del material difuso resultante es lo que el programador pretendía, pero el estado del material ambiental resultante es inesperadamente (1.0, 1.0, 1.0, 1.0). ¿Cómo ocurrió eso? Bueno, recuerde que el modo de material de color comienza inmediatamente a rastrear el color actual cuando se habilitó . El valor inicial para la configuración del material de color es GL_FRONT_AND_BACK y GL_AMBIENT_AND_DIFFUSE (probablemente no sea lo que esperaba).

Desde que permite el modo de material de color inmediatamente comienza el seguimiento del color actual , tanto en el ambiente y el material difuso estados son actualizado para que sea (1.0, 1.0, 1.0, 1.0). Tenga en cuenta que se pierde el efecto de inicial glMaterialfv. A continuación, el estado del material de color es actualizado para simplemente cambiar el material difuso frontal. Por último, la invocación glColor3f cambia el material difuso a (0.3, 0.5, 0.6, 1.0). El estado del material ambiental termina siendo (1.0, 1.0, 1.0, 1.0).

El problema en el fragmento de código anterior es que el modo de material de color está habilitado antes de llamar al glColorMaterial. El modo de material de color es muy efectivo para cambios de material simples eficientes, pero para evitar la trampa anterior, siempre tenga cuidado de configurar glColorMaterial antes de habilite GL_COLOR_MATERIAL.