TAPsOpenGLLightModel.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsOpenGLLightModel.hpp

Light Model for OpenGL

SUKITTI PUNAK   (05/12/2006)
UPDATE          (05/14/2006)
******************************************************************************/
#include "TAPsOpenGLLightModel.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs__OpenGL
//=============================================================================
template <typename T> GLint     OpenGLLightModel<T>::g_iGLMaxLights = 0;
template <typename T> GLuint    OpenGLLightModel<T>::g_uiGLDisplayList = 0;
template <typename T> int       OpenGLLightModel<T>::g_iTotalLights = 0;
//=============================================================================
// Constructor(s) and Destructor
//-----------------------------------------------------------------------------
template <typename T>
OpenGLLightModel<T>::OpenGLLightModel ()
    : m_bOn( false )
{
    if ( g_iGLMaxLights == 0 )  SetGLMaxLights();
    SetDefaultValues();
    ++g_iTotalLights;
}
//-----------------------------------------------------------------------------
template <typename T>
OpenGLLightModel<T>::OpenGLLightModel (
            T lightNumber,                                      // light#
            T ambientR,  T ambientG,  T ambientB,  T ambientA,  // ambient
            T diffuseR,  T diffuseG,  T diffuseB,  T diffuseA,  // diffuse
            T specularR, T specularG, T specularB, T specularA, // specular
            T positionX, T positionY, T positionZ, T positionW, // position
            T spotDirectionX = 0,       // spot direction x
            T spotDirectionY = 0,       // spot direction y
            T spotDirectionZ = -1,      // spot direction z
            T spotExponent = 0,         // spot exponent
            T spotCutoff = 180,         // spot cutoff
            T constantAttenuation = 1,  // constant attenuation
            T linearAttenuation = 0,    // linear attenuation
            T QuadraticAttenuation = 0  // quadratic attenuation
)   : m_bOn( false )
{
    if ( g_iGLMaxLights == 0 )  SetGLMaxLights();
    //-----------------------------------------------------
    SetGLLightNumber( lightNumber );
    //-----------------------------------------------------
    m_v4Ambient.SetXYZW( ambientR, ambientG, ambientB, ambientA );
    m_v4Diffuse.SetXYZW( diffuseR, diffuseG, diffuseB, diffuseA );
    m_v4Specular.SetXYZW( specularR, specularG, specularB, specularA );
    m_v4Position.SetXYZW( positionX, specularY, specularZ, specularW );
    //-------------------------------------------
    m_v3SpotDirection.SetXYZ( spotDirectionX, spotDirectionY, spotDirectionZ );
    m_tSpotExponent = spotExponent;
    m_tSpotCutoff   = spotCutoff;
    //-------------------------------------------
    m_tConstantAttenuation  = constantAttenuation;
    m_tLinearAttenuation    = linearAttenuation;
    m_tQuadraticAttenuation = quadraticAttenuation;
    //-----------------------------------------------------
    ++g_iTotalLights;
}
//-----------------------------------------------------------------------------
template <typename T>
OpenGLLightModel<T>::~OpenGLLightModel ()
{
    Disable();
    --g_iTotalLights;
}
//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
// Get/Set Function(s)
//-----------------------------------------------------------------------------
// Enable/Disable <==> On/Off
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::Enable ()
{
    m_bOn = true;
    //-----------------------------------------------------
//  glLightfv( m_eGLLightNumber, GL_AMBIENT, m_v4Ambient.GetDataFloat() );
//  glLightfv( m_eGLLightNumber, GL_DIFFUSE, m_v4Diffuse.GetDataFloat() );
//  glLightfv( m_eGLLightNumber, GL_SPECULAR, m_v4Specular.GetDataFloat() );
//  glLightfv( m_eGLLightNumber, GL_POSITION, m_v4Position.GetDataFloat() );
//  glLightfv( m_eGLLightNumber, GL_SPOT_DIRECTION, 
//             m_v3SpotDirection.GetDataFloat() );
//  glLightf( m_eGLLightNumber, GL_SPOT_EXPONENT, m_tSpotExponent );
//  glLightf( m_eGLLightNumber, GL_SPOT_CUTOFF, m_tSpotCutoff );
//  glLightf( m_eGLLightNumber, GL_CONSTANT_ATTENUATION, 
//            m_tConstantAttenuation );
//  glLightf( m_eGLLightNumber, GL_LINEAR_ATTENUATION, 
//            m_tLinearAttenuation );
//  glLightf( m_eGLLightNumber, GL_QUADRATIC_ATTENUATION, 
//            m_tQuadraticAttenuation );
    //-----------------------------------------------------
    glEnable( m_eGLLightNumber );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::Disable ()
{
    m_bOn = false;
    glDisable( m_eGLLightNumber );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::Switch ( bool on )
{
    m_bOn = on;
    if ( m_bOn ) {
        Enable();
    }
    else {
        Disable();
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::ToggleSwitch ()
{
    Switch( !m_bOn );
}
//-----------------------------------------------------------------------------
template <typename T>
bool OpenGLLightModel<T>::IsOn () const
{
    return m_bOn;
}
//-----------------------------------------------------------------------------
template <typename T>
bool OpenGLLightModel<T>::IsEnabled () const
{
    return m_bOn;
}
//-----------------------------------------------------------------------------
// GL_LIGHTi; 0 <= i < GL_MAX_LIGHTS
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetGLLightNumber ( int n )
{
    GLenum eGL = static_cast<GLint>(n) + GL_LIGHT0;
    SetGLLightNumber( eGL );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetGLLightNumber ( GLenum eGL )
{
    if ( eGL < GL_LIGHT0 )  eGL = GL_LIGHT0;
    GLenum eMaxLightNumber = GL_LIGHT0 + g_iGLMaxLights - 1;
    if ( eGL > eMaxLightNumber )    eGL = eMaxLightNumber;
    m_eGLLightNumber = eGL;
}
//-----------------------------------------------------------------------------
template <typename T>
int OpenGLLightModel<T>::GetGLLightNumber () const
{
    return m_eGLLightNumber - GL_LIGHT0;
}
//-----------------------------------------------------------------------------
// Light Ambient    [-1,1]
//   (Default: (0,0,0,1))
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetAmbient ( const Vector4<T> & v )
{
    m_v4Ambient.SetXYZW( v );
    glLightfv( m_eGLLightNumber, GL_AMBIENT, m_v4Ambient.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetAmbient ( const Vector3<T> & v )
{
    m_v4Ambient.SetXYZ( v );
    glLightfv( m_eGLLightNumber, GL_AMBIENT, m_v4Ambient.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetAmbient ( T r, T g, T b, T a )
{
    m_v4Ambient.SetXYZW( r, g, b, a );
    glLightfv( m_eGLLightNumber, GL_AMBIENT, m_v4Ambient.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetAmbient ( T r, T g, T b )
{
    m_v4Ambient.SetXYZ( r, g, b );
    glLightfv( m_eGLLightNumber, GL_AMBIENT, m_v4Ambient.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
const Vector4<T> & OpenGLLightModel<T>::GetAmbient () const
{
    return m_v4Ambient;
}
//-----------------------------------------------------------------------------
// Light Diffuse    [-1,1]
//   (Default: (1,1,1,1)) for GL_LIGHT0
//   (Default: (0,0,0,0)) for other
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetDiffuse ( const Vector4<T> & v )
{
    m_v4Diffuse.SetXYZW( v );
    glLightfv( m_eGLLightNumber, GL_DIFFUSE, m_v4Diffuse.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetDiffuse ( const Vector3<T> & v )
{
    m_v4Diffuse.SetXYZ( v );
    glLightfv( m_eGLLightNumber, GL_DIFFUSE, m_v4Diffuse.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetDiffuse ( T r, T g, T b, T a )
{
    m_v4Diffuse.SetXYZW( r, g, b, a );
    glLightfv( m_eGLLightNumber, GL_DIFFUSE, m_v4Diffuse.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetDiffuse ( T r, T g, T b )
{
    m_v4Diffuse.SetXYZ( r, g, b );
    glLightfv( m_eGLLightNumber, GL_DIFFUSE, m_v4Diffuse.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
const Vector4<T> & OpenGLLightModel<T>::GetDiffuse () const
{
    return m_v4Diffuse;
}
//-----------------------------------------------------------------------------
// Light Specular   [-1,1]
//   (Default: (1,1,1,1)) for GL_LIGHT0
//   (Default: (0,0,0,0)) for other
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetSpecular ( const Vector4<T> & v )
{
    m_v4Specular.SetXYZW( v );
    glLightfv( m_eGLLightNumber, GL_SPECULAR, m_v4Specular.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetSpecular ( const Vector3<T> & v )
{
    m_v4Specular.SetXYZ( v );
    glLightfv( m_eGLLightNumber, GL_SPECULAR, m_v4Specular.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetSpecular ( T r, T g, T b, T a )
{
    m_v4Specular.SetXYZW( r, g, b, a );
    glLightfv( m_eGLLightNumber, GL_SPECULAR, m_v4Specular.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetSpecular ( T r, T g, T b )
{
    m_v4Specular.SetXYZ( r, g, b );
    glLightfv( m_eGLLightNumber, GL_SPECULAR, m_v4Specular.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
const Vector4<T> & OpenGLLightModel<T>::GetSpecular () const
{
    return m_v4Specular;
}
//-----------------------------------------------------------------------------
// Light Position   (Default: (0,0,1,0))
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetPosition ( const Vector4<T> & v )
{
    m_v4Position.SetXYZW( v );
    glLightfv( m_eGLLightNumber, GL_POSITION, m_v4Position.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetPosition ( const Vector3<T> & v )
{
    m_v4Position.SetXYZ( v );
    glLightfv( m_eGLLightNumber, GL_POSITION, m_v4Position.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetPosition ( T x, T y, T z, T w )
{
    m_v4Position.SetXYZW( x, y, z, w );
    glLightfv( m_eGLLightNumber, GL_POSITION, m_v4Position.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetPosition ( T x, T y, T z )
{
    m_v4Position.SetXYZ( x, y, z );
    glLightfv( m_eGLLightNumber, GL_POSITION, m_v4Position.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
const Vector4<T> & OpenGLLightModel<T>::GetPosition () const
{
    return m_v4Position;
}
//-----------------------------------------------------------------------------
// Light Spot Direction (Default: (0,0,-1))
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetSpotDirection ( const Vector3<T> & v )
{
    m_v3SpotDirection.SetXYZ( v );
    glLightfv( m_eGLLightNumber, GL_SPOT_DIRECTION, 
               m_v3SpotDirection.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetSpotDirection ( T x, T y, T z )
{
    m_v3SpotDirection.SetXYZ( x, y, z );
    glLightfv( m_eGLLightNumber, GL_SPOT_DIRECTION, 
               m_v3SpotDirection.GetDataFloat() );
}
//-----------------------------------------------------------------------------
template <typename T>
const Vector3<T> & OpenGLLightModel<T>::GetSpotDirection () const
{
    return m_v3SpotDirection;
}
//-----------------------------------------------------------------------------
// Light Spot Exponent [0,128] (Default: 0)
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetSpotExponent ( T t )
{
    m_tSpotExponent = t;
    glLightf( m_eGLLightNumber, GL_SPOT_EXPONENT, m_tSpotExponent );
}
//-----------------------------------------------------------------------------
template <typename T>
T OpenGLLightModel<T>::GetSpotExponent () const
{
    return m_tSpotExponent;
}
//-----------------------------------------------------------------------------
// Light Spot Cutoff [0,90] & 180 (Default: 180)
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetSpotCutoff ( T t )
{
    m_tSpotCutoff = t;
    glLightf( m_eGLLightNumber, GL_SPOT_CUTOFF, m_tSpotCutoff );
}
//-----------------------------------------------------------------------------
template <typename T>
T OpenGLLightModel<T>::GetSpotCutoff () const
{
    return m_tSpotCutoff;
}
//-----------------------------------------------------------------------------
// Light Constant Attenuation  (Default: 1)
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetAttenuationConstant ( T t )
{
    m_tConstantAttenuation = t;
    glLightf( m_eGLLightNumber, GL_CONSTANT_ATTENUATION, 
              m_tConstantAttenuation );
}
//-----------------------------------------------------------------------------
template <typename T>
T OpenGLLightModel<T>::GetAttenuationConstant () const
{
    return m_tConstantAttenuation;
}
//-----------------------------------------------------------------------------
// Light Linear Attenuation    (Default: 0)
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetAttenuationLinear ( T t )
{
    m_tLinearAttenuation = t;
    glLightf( m_eGLLightNumber, GL_LINEAR_ATTENUATION, 
              m_tLinearAttenuation );
}
//-----------------------------------------------------------------------------
template <typename T>
T OpenGLLightModel<T>::GetAttenuationLinear () const
{
    return m_tLinearAttenuation;
}
//-----------------------------------------------------------------------------
// Light Quadratic Attenuation (Default: 0)
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetAttenuationQuadratic ( T t )
{
    m_tQuadraticAttenuation = t;
    glLightf( m_eGLLightNumber, GL_QUADRATIC_ATTENUATION, 
              m_tQuadraticAttenuation );
}
//-----------------------------------------------------------------------------
template <typename T>
T OpenGLLightModel<T>::GetAttenuationQuadratic () const
{
    return m_tQuadraticAttenuation;
}
//-----------------------------------------------------------------------------
//=============================================================================

/*
//=============================================================================
// Shadow Function(s)
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::GenerateShadowMap ( 
    //void (*DrawModels)( Enum::DrawMode DM ), 
    void (*DrawModels)(), 
    //OpenGLModelManager<T> obj, 
    //void (OpenGLModelManager<T>::*DrawModels)(), 
    T tDistance, int shadowSize )
{
    T   tNearPlane, tFarPlane, tFOV;
    GLfloat matrixLightModelView[16], matrixLightProjection[16];
    Vector3<T>  vPosition, vPointAt;
    //---------------------------------------------------------------
    if ( m_v4Position[4] != MATH<T>::Zero ) {
        vPosition[0] = m_v4Position[0] / m_v4Position[4];
        vPosition[1] = m_v4Position[1] / m_v4Position[4];
        vPosition[2] = m_v4Position[2] / m_v4Position[4];
    }
    else {
        vPosition[0] = m_v4Position[0] / 0.000001;
        vPosition[1] = m_v4Position[1] / 0.000001;
        vPosition[2] = m_v4Position[2] / 0.000001;
    }
    vPointAt[0] = ( vPosition[0] + m_v3SpotDirection[0] ) * tDistance;
    vPointAt[1] = ( vPosition[1] + m_v3SpotDirection[1] ) * tDistance;
    vPointAt[2] = ( vPosition[2] + m_v3SpotDirection[2] ) * tDistance;
    tNearPlane = 0; // = tToSceneDistance - 0;
    tFarPlane  = tDistance * 2;
    tFOV = 17000.0f / tDistance;
    //---------------------------------------------------------------
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    glPushMatrix();
        glMatrixMode( GL_PROJECTION );
        glLoadIdentity();
        gluPerspective( tFOV, 1.0f, tNearPlane, tFarPlane );
        glGetFloatv( GL_PROJECTION_MATRIX, matrixLightProjection );
        glPushMatrix();
            glMatrixMode( GL_MODELVIEW );
            glLoadIdentity();
            gluLookAt(  vPosition[0], vPosition[1], vPosition[2], 
                        vPointAt[0], vPointAt[1], vPointAt[2], 
                        0, 1, 0 );
            glGetFloatv( GL_MODELVIEW_MATRIX, matrixLightModelView );
            glViewport( 0, 0, shadowSize, shadowSize );
            glClear( GL_DEPTH_BUFFER_BIT );
            //-----------------------------------
            // 
            glShadeModel( GL_FLAT );
            glDisable( GL_LIGHTING );
            glDisable( GL_COLOR_MATERIAL );
            glDisable( GL_NORMALIZE );
            glColorMask( 0, 0, 0, 0 );
            //-----------------------------------
            glEnable( GL_POLYGON_OFFSET_FILL );
            //-----------------------------------
            // Draw Object Here
            (* DrawModels)( DM );
            //-----------------------------------
            glCopyTexImage2d( GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 0, 0, shadowSize, shadowSize, 0 );
            //-----------------------------------
            // Restore normal drawing states
            //glShadeModel( GL_SMOOTH );
            //glEnsable( GL_LIGHTING );
            //glEnable( GL_COLOR_MATERIAL );
            //glEnable( GL_NORMALIZE );
            //glColorMask( 1, 1, 1, 1 );
            //-----------------------------------
            // Set up texture matrix for shadow map projection
            glMatrixMode( GL_TEXTURE );
            glLoadIdentity();
            glTranslatef(0.5f, 0.5f, 0.5f);
            glScalef(0.5f, 0.5f, 0.5f);
            glMultMatrixf( matrixLightProjection );
            glMultMatrixf( matrixLightModelView );
            //-----------------------------------
        glPopMatrix();
        glMatrixMode( GL_PROJECTION );
    glPopMatrix();
    glPopAttrib();
    //---------------------------------------------------------------
    //---------------------------------------------------------------
    //---------------------------------------------------------------
}
//-----------------------------------------------------------------------------
//=============================================================================
//*/

//=============================================================================
// Static Function(s)
//-----------------------------------------------------------------------------
template <typename T>
int OpenGLLightModel<T>::GetNumberOfLights ()
{
    return g_iTotalLights;
}
//-----------------------------------------------------------------------------
template <typename T>
int OpenGLLightModel<T>::GetMaxinumNumberOfLightsAllowed ()
{
    return static_cast<int>( g_iGLMaxLights );
}
//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
// Private Function(s)
//-----------------------------------------------------------------------------
template <typename T>   // Static Fn
void OpenGLLightModel<T>::SetGLMaxLights ()
{
    glGetIntegerv( GL_MAX_LIGHTS, &g_iGLMaxLights );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLLightModel<T>::SetDefaultValues ()
{
    SetGLLightNumber( g_iTotalLights );
    //-----------------------------------------------------
    m_v4Ambient.SetXYZW( 0, 0, 0, 1 );
    if ( g_iTotalLights == GL_LIGHT0 ) {
        m_v4Diffuse.SetXYZW( 1, 1, 1, 1 );
        m_v4Specular.SetXYZW( 1, 1, 1, 1 );
    }
    else {
        m_v4Diffuse.SetXYZW( 0, 0, 0, 0 );
        m_v4Specular.SetXYZW( 0, 0, 0, 0 );
    }
    m_v4Position.SetXYZW( 0, 0, 1, 0 );
    //-------------------------------------------
    m_v3SpotDirection.SetXYZ( 0, 0, -1 );
    m_tSpotExponent = 0;
    m_tSpotCutoff   = 180;
    //-------------------------------------------
    m_tConstantAttenuation  = 1;
    m_tLinearAttenuation    = 0;
    m_tQuadraticAttenuation = 0;
    //-----------------------------------------------------
}
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----