.
Estoy realizando pruebas con OpenGL+C ( No me recomienden otro por que antes de cambiarme quiero solucionar este problema ), y estoy con las luces. mi problema radica en que la luz no apunta a donde deberia de apunter ( Algo asi como un Eje ), ya que se mueve emisor d ela luz a otra coordenada y obviamente el eje (en este caso esta representado con una espera solida) deberia estar SIEMPRE iluminado, pero no es asi...

alguien me puede ayudar?



#include <windows.h>
#include "include/OpenGL/CGL.h"

// Posicion de la luz X, Y, Y, {el 4to elemento indica si es en una posicion infinita 1=NO, 0=SI}
float fposition[4] = {0.0f, 0.0f, 1.0f, 1.0};

void drawZones()
{
   ::glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  // Borramos la pantalla y el buffer de profundidad

   ::glLoadIdentity();
   //  Camara.
   ::gluLookAt( 0, 0, 5,               //  Posicon X, Y, Z.
                0, 0, -1,              //  Hacia donde vemos X, Y, Z.
                0.0f, 1.0f, 0.0f );    // Cielo X, Y, Z.

   GLfloat fDirection[] = {0.0,0.0,-1.0}; // Dirrecion hacia adonde apuntamos.
   //Configuramos nuestra Luz.
   ::glEnable ( GL_LIGHT0 );
   ::glLightfv ( GL_LIGHT0, GL_POSITION, fposition );
   ::glLightfv ( GL_LIGHT0, GL_SPOT_DIRECTION, fDirection);
   ::glLightf ( GL_LIGHT0, GL_SPOT_CUTOFF, 5 );

   ::glutSolidSphere(100, 4000, 4000); // Esfero que nos representara las paredes.

   //  Las siguiente son las esferas donde esta la luz.
   //  Posicion del emisor de luz.
   ::glPushMatrix ();
       ::glColor3f ( 1.0f , 0.0f , 0.0f );
       ::glTranslatef ( fposition[0],fposition[1],fposition[2] );
       ::glutWireSphere ( 0.2, 50 , 50 );
   ::glPopMatrix ();

   //  Posicion Destino hacia donde se emite la luz.
   ::glPushMatrix();
       ::glColor3f( 0.0f , 0.0f , 1.0f );
       ::glTranslatef( fDirection[0],fDirection[1],fDirection[2] );
       ::glutSolidSphere( 0.2, 50 , 50 );
   ::glPopMatrix();
   //  Mostramos.
   ::glutSwapBuffers();
}

void keyBoardSFunc(int key, int x, int y)
{
   if (key == GLUT_KEY_LEFT)
       fposition[0] -= 0.1;
   if (key == GLUT_KEY_RIGHT)
       fposition[0] += 0.1;
   if (key == GLUT_KEY_UP)
       fposition[1] -= 0.1;;
   if (key == GLUT_KEY_DOWN)
       fposition[1] += 0.1;
}
void timer( int val ) {
   ::glutTimerFunc       ( 10 , timer,  0);
   ::glutPostRedisplay   (  );
}

int main()
{
   CGL oWindow;

   oWindow.creaVentanaGL ( "Hola Mundo desde OpenGL" , 1024 , 726 , 0 , 0 , false );
   ::glutDisplayFunc ( drawZones );
   ::glutSpecialFunc ( keyBoardSFunc );
   ::glutTimerFunc ( 10, timer, 0 );
   ::glutMainLoop ();

   return EXIT_SUCCESS;
}



CGL.cpp




#include "OpenGL/cgl.h"

//---------------------------------------------------------------
// Nombre: Constructor
// Descripcion: Constructor de la clase. Inicializa las variables
// Parametros: Ninguno
//---------------------------------------------------------------
CGL::CGL()
{
   int_Win = 0;
}

//---------------------------------------------------------------
// Nombre: Destructor
// Descripcion: Destructor de la clase
// Parametros: Ninguno
//---------------------------------------------------------------
CGL::~CGL()
{
   eliminaVentanaGL();
}

//---------------------------------------------------------------
// Nombre: inicializaEscenaGL
// Descripcion: Inicializa los parametros iniciales de la escena
// Parametros:
//        Glsizei ancho: Ancho de la escena
//        Glsizei alto: Alto de la escena
//---------------------------------------------------------------
void CGL::inicializaEscenaGL(GLsizei ancho, GLsizei alto)
{
   if ( alto <= 0 )                                                                    // Previene de la división entre 0
   {
       alto=1;                                                                         // Establece la altura = 1
   }
   ::glViewport            ( 0 , 0 , ancho , alto );                                   // Resetea el actual puerto de visión (ViewPort)
   ::glMatrixMode          ( GL_PROJECTION );                                          // Selecciona la matriz de proyección
   ::glLoadIdentity        (  );                                                       // Resetea la matriz de proyección

   ::gluPerspective        ( 45.0f , (GLfloat)ancho/(GLfloat)alto , 1.0f , 300000.0f );  // Calcula el Aspect Ratio de la ventana

   ::glMatrixMode          ( GL_MODELVIEW );                                           // Selecciona la matriz de modelado
   ::glLoadIdentity        (  );                                                       // Resetea la matriz de modelado
}

//---------------------------------------------------------------
// Nombre: iniGL
// Descripcion: Inicializa los valores iniciales de OGL
// Parametros: Ninguno
//---------------------------------------------------------------
bool CGL::iniGL(void)
{
   GLfloat ambientLight[]  = { 0.1f, 0.1f, 0.1f, 1.0f };
   ::glShadeModel          ( GL_SMOOTH );                                  // Activa sombreado suave (Smooth Shading)
   ::glClearDepth          ( 1.0f );                                       // Depth Buffer Setup
   ::glEnable              ( GL_DEPTH_TEST );                              // Activa Z-Buffer
   ::glDepthFunc           ( GL_LEQUAL );                                  // El tipo de Depth Testing que se va a realizar
   ::glHint                ( GL_PERSPECTIVE_CORRECTION_HINT , GL_NICEST ); // Muy buena correción de perspectiva
   ::glEnable              ( GL_TEXTURE_2D );                              // Activa mapeado de texturas
   ::glColorMaterial       ( GL_FRONT , GL_AMBIENT_AND_DIFFUSE );
   ::glClearColor          ( 0.0f , 0.0f , 0.0f , 1.0f );

   ::glLightModeli         ( GL_LIGHT_MODEL_TWO_SIDE , 1 );                // habilita ambas caras (FRONT-iluminada & BACK-oscurecida) de los poligonos
   ::glLightModelfv        ( GL_LIGHT_MODEL_AMBIENT , ambientLight );      // luz ambiental de toda la escena
   ::glEnable              ( GL_COLOR_MATERIAL);                           // habilita el color para los materiales (poligonos rellenos)
   ::glEnable              ( GL_LIGHTING );

   return true;
}

//---------------------------------------------------------------
// Nombre: eliminaVentanaGL
// Descripcion: Destruye toda la información sobre la ventana GL
// Parametros: Ninguno
//---------------------------------------------------------------
void CGL::eliminaVentanaGL(void)
{
   ::glutDestroyWindow(  this->int_Win );
   this->int_Win = 0;
}

//---------------------------------------------------------------
// Nombre: CrearVentanaGL
// Descripcion: Crea una ventana OGL
// Parametros:
//            char* Titulo: Titulo de la ventana
//            int ancho: Ancho de la ventana o en modo pantalla completa
//            int alto: Alto de la ventana o en modo pantalla completa
//            bool fullscreen: Usar pantalla completa (TRUE) o ventana (FALSE)
//---------------------------------------------------------------
bool CGL::creaVentanaGL(const char* Titulo, GLsizei ancho, GLsizei alto, GLsizei x, GLsizei y, bool fullscreen)
{
   if ( x < 0 ) { x=0; }
   if ( y < 0 ) { y=0; }

   ::glutInitDisplayMode ( GLUT_DOUBLE | GLUT_RGBA );
   ::glutInitWindowPosition ( x , y );
   ::glutInitWindowSize ( ancho , alto );

   this->int_Win = ::glutCreateWindow( Titulo );

   ::glutSetWindow( this->int_Win );

   if ( fullscreen == true )
       ::glutFullScreen();

   inicializaEscenaGL ( ancho , alto );        // Inicializamos la escena en perspectiva GL

   if ( !iniGL() ) {
       eliminaVentanaGL();
       return false;
   }

   return true;
}



CGL.h


#ifndef _cGL_H_
#define _cGL_H_

// INCLUDES //////////////////////////////////////
#include <windows.h>            // Archivo cabecera para Windows
#include <GL/glut.h>

class CGL
{
   public:
       CGL                                         ();
       virtual         ~CGL                        ();
       bool            creaVentanaGL               (const char* Titulo, GLsizei ancho, GLsizei alto, GLsizei x, GLsizei y, bool fullscreen);
       void            inicializaEscenaGL          (GLsizei ancho, GLsizei alto);      // Cambia de tamaño e inicializa la ventana GL
       void            eliminaVentanaGL            (void);                           // Elimina la ventana
       int             int_Win;
       void            inilight                    (GLfloat ligt[]);
   private:
       bool            iniGL                       (void);                        // Todas la inicializaciónes de OpenGl vienen aqui
};

#endif



Temibles Lunas!¡