.
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!¡