OpenGL ES Pregunta Luz

Question

Soy nuevo en OpenGL ES y están desarrollando en Objective-C para el iPhone.

Lo que estoy tratando de entender es cómo la luz se coloca en mi tronco. Así es como lo hago:

crear un cuadrado y lo puso como "baja" en mi tronco. Estoy poniendo la luz, justo encima, en el centro de la pista y el punto de la dirección de la luz abajo a la derecha. Ahora, espero que el círculo de luz en el suelo para estar en el medio. Pero no es, it'r más a la parte posterior (futher de distancia). ¿Cómo?

near = 8.0
far = 28
light position = {0.0, 0.0, -10.0}
light direction = {0.0, -1.0, 0.0}

Floor coordinates = {-0.3153, -0.473, -20.0},
{-0.3153, -0.473, 0.0},
{0.3153, -0.473, -20.0},
{0.3153, -0.473, 0.0},

¿No debería hacer esto juntos el círculo de luz que estar en el centro de la pista y no se encuentra un poco hacia atrás?

Aquí está mi código significativa:

Configuración de la vista:

 -(void)setupView:(TDRoomView*)view
    {


    const GLfloat zNear = 8, zFar = 28, fieldOfView = 5; 

 GLfloat size; 
 glEnable(GL_DEPTH_TEST);
 glMatrixMode(GL_PROJECTION); 
 size = zNear * tanf(DEGREES_TO_RADIANS(fieldOfView) / 2.0); 
 NSLog(@"tanf(DEGREES_TO_RADIANS(fieldOfView)/2.0); %f ", tanf(DEGREES_TO_RADIANS(fieldOfView)/2.0));

 CGRect rect = view.bounds; 
 glFrustumf(-size, size, -size / (rect.size.width / rect.size.height), size / 
      (rect.size.width / rect.size.height), zNear, zFar);  
 glViewport(-size, size, rect.size.width, rect.size.height);  
 glMatrixMode(GL_MODELVIEW);
    glShadeModel(GL_SMOOTH);
 glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_LIGHTING);

    glEnable(GL_LIGHT0);

 static const Color3D light0Ambient[] = {{1.0, 1.0, 1.0, 1.0}};
 glLightfv(GL_LIGHT0, GL_AMBIENT, (const GLfloat *)light0Ambient);

    static const Color3D light0Diffuse[] = {{0.5, 0.5, 0.5, 1.0}};
 glLightfv(GL_LIGHT0, GL_DIFFUSE, (const GLfloat *)light0Diffuse);

    static const Color3D light0Specular[] = {{0.5, 0.5, 0.5, 1.0}};
    glLightfv(GL_LIGHT0, GL_SPECULAR, (const GLfloat *)light0Specular);

    static const Vertex3D light0Position[] = {{0.0, 0.473, -10.0}};
 glLightfv(GL_LIGHT0, GL_POSITION, (const GLfloat *)light0Position); 

 static const Vertex3D lightVector= {0.0, -1.0, 0.0};

    glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, (GLfloat *)&lightVector);

    glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 85);

 glLoadIdentity(); 
 glClearColor(0.0f, 0.0f, 1.0f, 1.0f); 

    }

Y dibujo:

     -(void)drawView:(TDRoomView*)view
    {

        static const Vertex3D vertices[]= {
  {-0.3153, -0.473, -20.0},
  {-0.3153, -0.473, 0.0},
  {0.3153, -0.473, -20.0},
  {0.3153, -0.473, 0.0},
  {-0.1, -0.25, -3.0},
  {0.0, 0.0, -10.0},
  {0.1, -0.25, -3.0}
 };

 static const Color3D colors[] = {
  {0.7, 0.7, 0.7, 1.0},
  {0.7, 0.7, 0.7, 1.0},
  {0.7, 0.7, 0.7, 1.0},
  {0.7, 0.7, 0.7, 1.0},
  {1.0, 0.0, 0.0, 1.0},
  {0.0, 1.0, 0.0, 1.0},
  {0.0, 0.0, 1.0, 1.0}
       };


 static const GLubyte roomFaces[] = {
  0, 1, 2,
  1, 2, 3};


        static const Vector3D normals[] = {
  {0.000000, 1.000000, 0.000000},
  {0.000000, 1.000000, 0.000000},
  {0.000000, 1.000000, 0.000000},
  {0.000000, 1.000000, 0.000000},
  {0.000000, 1.000000, 0.000000},
  {0.000000, 1.000000, 0.000000},
  {0.000000, 1.000000, 0.000000}
 };

    glLoadIdentity();

    glClearColor(0.7, 0.7, 0.7, 1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glEnableClientState(GL_VERTEX_ARRAY);
 glEnableClientState(GL_COLOR_ARRAY);
 glEnableClientState(GL_NORMAL_ARRAY);

        glVertexPointer(3, GL_FLOAT, 0, vertices);
 glColorPointer(4, GL_FLOAT, 0, colors);
 glNormalPointer(GL_FLOAT, 0, normals);
 glDrawElements(GL_TRIANGLE_STRIP, 8, GL_UNSIGNED_BYTE, roomFaces);

        glDisableClientState(GL_NORMAL_ARRAY);
 glDisableClientState(GL_VERTEX_ARRAY);
 glDisableClientState(GL_COLOR_ARRAY); }

Además, me Recon cambiar el

static const Vertex3D light0Position[] = {{0.0, 0.473, -10.0}};

a

static const Vertex3D light0Position[] = {{0.0, 0.473, -8.0}}; 

Bord se vuelve oscura, sin luz incide sobre él. ¿Por qué, sólo movió la luz dos pasos más cerca ...? Las mismas cosas suceden si lo muevo dos pasos más allá de esta manera:

static const Vertex3D light0Position[] = {{0.0, 0.473, -12.0}};

Cualquier ayuda con el fin de "arrojar luz som" en mi problema es muy apreciada! (No se pudo evitarlo ...;))

Gracias de antemano!

Answer 1

Le sugiero que haga una cuadrícula más grande con más vértices, preferentemente n por n cuadrados. Trate de no tener demasiado tiempo triángulos finos. Esto hará que sea más fácil de ver donde la luz parece ser que la luz se calcula para cada vértice y no por píxel para la superficie.

http://www.opengl.org/resources/features/KilgardTechniques/ oglpitfall /

  

2. La mala iluminación teselación Hurts

     

cálculos de iluminación de OpenGL se realizan por vértice. Esto significa que los cálculos de sombreado debido a las fuentes de luz que interactúan con el material de la superficie de un objeto 3D solamente se calculan en los vértices del objeto. Por lo general, sólo OpenGL interpola o tonos suaves entre colores de los vértices. de OpenGL iluminación por vértice funciona bastante bien, excepto cuando se pierde o borrosa un efecto de iluminación tal como un reflejo especular o un centro de atención porque el efecto no está suficientemente muestreada por los vértices de un objeto. Tal sub-muestreo de efectos de iluminación se produce cuando los objetos se modelan en trozos grandes de usar un número mínimo de vértices.

     

:

     

Los usuarios sin experiencia OpenGL son a menudo tentados a habilitar la funcionalidad de punto de mira de OpenGL y brillar una luz sobre una pared modelada como una sola gran polígono. Por desgracia, hay un patrón centro de atención aguda aparecerá como el novato destinado; probablemente no verá ningún centro de atención afecta en absoluto. El problema es que los medios de corte del proyector que las esquinas extremas de la pared donde se especifican los vértices quedan ninguna contribución de la atención y desde esas son las únicas vértices la pared tiene, no habrá ningún patrón de luz sobre la pared.

Answer 2

GL_POSITION se especifica en coordenadas homogéneas, lo que significa que requiere cuatro valores, no tres. Es necesario especificar w = 1.0 para la fuente de luz, pero su w componente es en cambio vendrá de lo que sucede a estar al lado de light0Position en la memoria.

(Parte de la razón por la que es GL_POSITION en coordenadas homogéneas es que permitirá definir las luces direccionales mediante el establecimiento de una posición con w = 0.0).