TAPsOpenGLCameraModel.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsOpenGLCameraModel.hpp

Camera Model for OpenGL

SUKITTI PUNAK   (05/13/2006)
UPDATE          (12/14/2010)
******************************************************************************/
#include "TAPsOpenGLCameraModel.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> GLuint    OpenGLCameraModel<T>::g_uiGLDisplayList = 0;
template <typename T> int       OpenGLCameraModel<T>::g_iTotalCameras = 0;
//=============================================================================
// Constructor(s) and Destructor
//-----------------------------------------------------------------------------
template <typename T>
OpenGLCameraModel<T>::OpenGLCameraModel ( 
    Enum::CameraType    cameraType          // Orthographic or Perspective
)
{
    SetDefaultValues( cameraType );
    ++g_iTotalCameras;
}
//-----------------------------------------------------------------------------
template <typename T>
OpenGLCameraModel<T>::OpenGLCameraModel (
    Enum::CameraType    cameraType,         // Orthographic or Perspective
    T positionX, T positionY, T positionZ,          // position
    T centerX, T centerY, T centerZ,                // center
    T orientationX, T orientationY, T orientationZ, // orientation
    T tLeft,   T tRight,    // left & right projections
    T tBottom, T tTop,      // bottom & top projections
    T tNear,   T tFar       // near & far   projections
)
{
    //-------------------------------------------
    m_eCameraType = cameraType;
    //------------------------------------
    m_v3Position.SetXYZ( positionX, positionY, positionZ );
    m_v3Center.SetXYZ( centerX, centerY, centerZ );
    m_v3Orientation.SetXYZ( orientationX, orientationY, orientationZ );
    //------------------------------------
    m_tLeft   = tLeft;
    m_tRight  = tRight;
    m_tBottom = tBottom;
    m_tTop    = tTop;
    m_tNear   = tNear;
    m_tFar    = tFar;
    //------------------------------------
    SetProjectionMatrix();
    //-------------------------------------------
    ++g_iTotalCameras;
}
//-----------------------------------------------------------------------------
template <typename T>
OpenGLCameraModel<T>::OpenGLCameraModel (
    Enum::CameraType    cameraType,         // Orthographic or Perspective
    T positionX, T positionY, T positionZ,          // position
    T centerX, T centerY, T centerZ,                // center
    T orientationX, T orientationY, T orientationZ, // orientation
    T tFovy,    // angle of the field of view in the yz-plane [0,180]
    T tAspect,  // aspect ratio (width/height of the view port)
    T tNear,    // near clipping plane
    T tFar      // far  clipping plane
)
{
    //-------------------------------------------
    m_eCameraType = cameraType;
    //------------------------------------
    m_v3Position.SetXYZ( positionX, positionY, positionZ );
    m_v3Center.SetXYZ( centerX, centerY, centerZ );
    m_v3Orientation.SetXYZ( orientationX, orientationY, orientationZ );
    //------------------------------------
    // fovy, aspect, near, far ???
    //------------------------------------
    SetProjectionMatrix();
    //-------------------------------------------
    ++g_iTotalCameras;
}
//-----------------------------------------------------------------------------
template <typename T>
OpenGLCameraModel<T>::~OpenGLCameraModel ()
{
    //Disable();
    --g_iTotalCameras;
}
//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
// Get/Set Function(s)
//-----------------------------------------------------------------------------
// Set <--> Camera starts shooting
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::Set ()
{
    //SetViewVolume();
    //---------------------------------------------------------------
    //if ( T type double
    GLfloat M[16];

    M[ 0] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[ 0] );
    M[ 1] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[ 4] );
    M[ 2] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[ 8] );
    M[ 3] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[12] );
    M[ 4] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[ 1] );
    M[ 5] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[ 5] );
    M[ 6] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[ 9] );
    M[ 7] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[13] );
    M[ 8] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[ 2] );
    M[ 9] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[ 6] );
    M[10] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[10] );
    M[11] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[14] );
    M[12] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[ 3] );
    M[13] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[ 7] );
    M[14] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[11] );
    M[15] = static_cast<GLfloat>( m_M4x4ProjectionMatrix[15] );

    glPushAttrib( GL_TRANSFORM_BIT );
    //glMatrixMode( GL_MODELVIEW );
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    glMultMatrixf( M );
    glMatrixMode( GL_MODELVIEW );
    glTranslatef( -m_v3Position[0], -m_v3Position[1], -m_v3Position[2] );
    glPopAttrib();
}
//-----------------------------------------------------------------------------
// Set View Volume (Camera's view range/volume)
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetViewVolume ()
{
    if ( m_eCameraType == Enum::PERSPECTIVE ) {
        SetPerspectiveViewVolume();
    }
    else {
        SetOrthographicViewVolume();
    }
}
//-----------------------------------------------------------------------------
// Camera Type
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetCameraType ( Enum::CameraType cameraType )
{
    if ( cameraType == m_eCameraType )  return;
    //-----------------------------------------------------
    // Switch Camera Type
    m_eCameraType = cameraType;
    //-----------------------------------------------------
    //SetViewVolume();
}
//-----------------------------------------------------------------------------
template <typename T>
Enum::CameraType OpenGLCameraModel<T>::GetCameraType () const
{
    return m_eCameraType;
}
//-----------------------------------------------------------------------------
/*
//-----------------------------------------------------------------------------
// Enable/Disable <==> On/Off
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::Enable ()
{
    m_bOn = true;
    //-----------------------------------------------------
    glCamerafv( m_eGLCameraNumber, GL_AMBIENT, &m_v4Ambient.GetDataFloat() );
    glCamerafv( m_eGLCameraNumber, GL_DIFFUSE, &m_v4Diffuse.GetDataFloat() );
    glCamerafv( m_eGLCameraNumber, GL_SPECULAR, &m_v4Specular.GetDataFloat() );
    glCamerafv( m_eGLCameraNumber, GL_POSITION, &m_v4Position.GetDataFloat() );
    glCamerafv( m_eGLCameraNumber, GL_SPOT_DIRECTION, 
               &m_v3SpotDirection.GetDataFloat() );
    glCameraf( m_eGLCameraNumber, GL_SPOT_EXPONENT, m_tSpotExponent );
    glCameraf( m_eGLCameraNumber, GL_SPOT_CUTOFF, m_tSpotCutoff );
    glCameraf( m_eGLCameraNumber, GL_CONSTANT_ATTENUATION, 
              m_tConstantAttenuation );
    glCameraf( m_eGLCameraNumber, GL_LINEAR_ATTENUATION, 
              m_tLinearAttenuation );
    glCameraf( m_eGLCameraNumber, GL_QUADRATIC_ATTENUATION, 
              m_tQuadraticAttenuation );
    //-----------------------------------------------------
    glEnable( m_eGLCameraNumber );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::Disable ()
{
    m_bOn = false;
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::Switch ( bool on )
{
    m_bOn = on;
    if ( m_bOn ) {
        glEnable( m_eGLCameraNumber );
    }
    else {
        glDisable( m_eGLCameraNumber );
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::ToggleSwitch ()
{
    m_bOn = !m_bOn;
    if ( m_bOn ) {
        glEnable( m_eGLCameraNumber );
    }
    else {
        glDisable( m_eGLCameraNumber );
    }
}
//-----------------------------------------------------------------------------
template <typename T>
bool OpenGLCameraModel<T>::IsOn () const
{
    return m_bOn;
}
//-----------------------------------------------------------------------------
template <typename T>
bool OpenGLCameraModel<T>::IsEnabled () const
{
    return m_bOn;
}
//*/
//-----------------------------------------------------------------------------
// Camera Position
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetPosition ( const Vector3<T> & p )
{
    m_v3Position = p;
    SetProjectionMatrix();
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetPosition ( T x, T y, T z )
{
    m_v3Position.SetXYZ( x, y, z );
    SetProjectionMatrix();
}
//-----------------------------------------------------------------------------
template <typename T>
const Vector3<T> & OpenGLCameraModel<T>::GetPosition () const
{
    return m_v3Position;
}
//-----------------------------------------------------------------------------
// Camera Center
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetCenter ( const Vector3<T> & p )
{
    m_v3Center = p;
    SetProjectionMatrix();
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetCenter ( T x, T y, T z )
{
    m_v3Center.SetXYZ( x, y, z );
    SetProjectionMatrix();
}
//-----------------------------------------------------------------------------
template <typename T>
const Vector3<T> & OpenGLCameraModel<T>::GetCenter () const
{
    return m_v3Center;
}
//-----------------------------------------------------------------------------
// Camera Orientation
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetOrientation ( const Vector3<T> & v )
{
    m_v3Orientation = v;
    SetProjectionMatrix();
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetOrientation ( T x, T y, T z )
{
    m_v3Orientation.SetXYZ( x, y, z );
    SetProjectionMatrix();
}
//-----------------------------------------------------------------------------
template <typename T>
const Vector3<T> & OpenGLCameraModel<T>::GetOrientation () const
{
    return m_v3Orientation;
}
//-----------------------------------------------------------------------------
// View Volume for Either Orthographic or Perspective Camera
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetViewVolume ( 
    T tLeft, T tRight, T tBottom, T tTop, T tNear, T tFar )
{
    //-------------------------------------------
    m_tLeft   = tLeft;
    m_tRight  = tRight;
    m_tBottom = tBottom;
    m_tTop    = tTop;
    m_tNear   = tNear;
    m_tFar    = tFar;
    //-------------------------------------------
    //SetViewVolume();
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetViewVolumeLeftAndRight ( T tLeft, T tRight )
{
    //-------------------------------------------
    m_tLeft   = tLeft;
    m_tRight  = tRight;
    //-------------------------------------------
    //SetViewVolume();
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetViewVolumeBottomAndTop ( T tBottom, T tTop )
{
    //-------------------------------------------
    m_tBottom = tBottom;
    m_tTop    = tTop;
    //-------------------------------------------
    //SetViewVolume();
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetViewVolumeNearAndFar ( T tNear, T tFar )
{
    //-------------------------------------------
    m_tViewVolumeNear   = tNear;
    m_tFar    = tFar;
    //-------------------------------------------
    //SetViewVolume();
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::GetViewVolume ( 
    T & tLeft, T & tRight, T & tBottom, T & tTop, T & tNear, T & tFar ) const
{
    tLeft   = m_tViewVolumeLeft;
    tRight  = m_tRight;
    tBottom = m_tBottom;
    tTop    = m_tTop;
    tNear   = m_tNear;
    tFar    = m_tFar;
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::GetViewVolumeLeftAndRight ( 
    T & tLeft, T & tRight ) const
{
    tLeft   = m_tLeft;
    tRight  = m_tRight;
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::GetViewVolumeBottomAndTop ( 
    T & tBottom, T & tTop ) const
{
    tBottom = m_tBottom;
    tTop    = m_tTop;
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::GetViewVolumeNearAndFar ( T & tNear, T & tFar ) const
{
    tNear   = m_tNear;
    tFar    = m_tFar;
}
//-----------------------------------------------------------------------------
// View Volume for Perspective Camera Only
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetViewVolumePerspective ( 
    T tFovy, T tAspect, T tNear, T tFar )
{
    // ???
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::GetViewVolumePerspective ( 
    T & tFovy, T & tAspect, T & tNear, T & tFar ) const
{
    // ???
}
//-----------------------------------------------------------------------------
// Viewport
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetViewPort ( const Vector4<int> & v )
{
    m_v4iViewport.SetXYZW( v );
    glViewport( m_v4iViewport[0], m_v4iViewport[1], m_v4iViewport[2], m_v4iViewport[3] );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetViewPort ( int x, int y, int width, int height )
{
    m_v4iViewport.SetXYZW( x, y, width, height );
    glViewport( m_v4iViewport[0], m_v4iViewport[1], m_v4iViewport[2], m_v4iViewport[3] );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetViewPortLowerLeftCorner ( int x, int y )
{
    m_v4iViewport[0] = x;
    m_v4iViewport[1] = y;
    glViewport( m_v4iViewport[0], m_v4iViewport[1], m_v4iViewport[2], m_v4iViewport[3] );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetViewPortWidthAndHeight ( int width, int height )
{
    m_v4iViewport[2] = width;
    m_v4iViewport[3] = height;
    glViewport( m_v4iViewport[0], m_v4iViewport[1], m_v4iViewport[2], m_v4iViewport[3] );
}
//-----------------------------------------------------------------------------
template <typename T>
const Vector4<int> & OpenGLCameraModel<T>::GetViewPort () const
{
    return m_v4iViewport;
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::GetViewPort ( 
    int & x, int & y, int & width, int & height ) const
{
    m_v4iViewport.GetXYZW( x, y, width, height );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::GetViewPortLowerLeftCorner ( 
    int & x, int & y ) const
{
    x = m_v4iViewport[0];
    y = m_v4iViewport[1];
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::GetViewPortWidthAndHeight ( 
    int & width, int & height ) const
{
    width  = m_v4iViewport[2];
    height = m_v4iViewport[3];
}
//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
// Static Function(s)
//-----------------------------------------------------------------------------
template <typename T>
int OpenGLCameraModel<T>::GetNumberOfCameras ()
{
    return g_iTotalCameras;
}
//-----------------------------------------------------------------------------
//=============================================================================

//=============================================================================
// Private Function(s)
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetDefaultValues ( Enum::CameraType cameraType )
{
    m_eCameraType = cameraType;
    //-----------------------------------------------------
    if ( m_eCameraType == Enum::PERSPECTIVE ) {
        m_v3Position.SetXYZ( 0, 0, 25 );
        //-----------------------------
        // near and far must be positive (so near should be less than far, and it can be zero)
        m_tLeft   = -0.5;   m_tRight = 0.5;
        m_tBottom = -0.5;   m_tTop   = 0.5;
        m_tNear   =  1;     m_tFar   = 200;
        //T w = m_tRight - m_tLeft;
        //T h = m_tTop - m_tBottom;
        //T aspect = w / h;
        //-----------------------------
    }
    else { // for orthogonal view
        m_v3Position.SetXYZ( 0, 0, 25 );
        //-----------------------------
        // near and far can be negative if to include viewing volume behind the viewer
        m_tLeft   = -25;    m_tRight = 25;
        m_tBottom = -25;    m_tTop   = 25;
        m_tNear   =  0;     m_tFar   = 200;
        //-----------------------------
    }
    //-------------------------------------------
    m_v3Center.SetXYZ( 0, 0, 0 );
    //-------------------------------------------
    m_v3Orientation.SetXYZ( 0, 1, 0 );
    //-------------------------------------------
    m_v4iViewport.SetXYZW( 0, 0, 400, 400 );
    //-----------------------------------------------------
    SetProjectionMatrix();
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetProjectionMatrix ()
{
    /*
    //-------------------------------------------
    // Projection Matrix
    //-------------------
    //         S[0]  S[1]  S[2]  0   // 0  4  8 12 
    // Proj =  U[0]  U[1]  U[2]  0   // 1  5  9 13
    //        -F[0] -F[1] -F[2]  0   // 2  6 10 14
    //          0     0     0    1   // 3  7 11 15
    // Where S = F x UP
    //       U = S x F
    //       F = (Center - Position) / ||Center - Position||
    //      UP = Orientation / ||Orientation||
    Vector3<T> F = (m_v3Center - m_v3Position).Normalized();
    Vector3<T> S = F ^ m_v3Orientation.Normalized();
    Vector3<T> U = S ^ F;
    //-------------------------------------------
    m_M4x4ProjectionMatrix[ 0] =  S[0];
    m_M4x4ProjectionMatrix[ 1] =  U[0];
    m_M4x4ProjectionMatrix[ 2] = -F[0];
    m_M4x4ProjectionMatrix[ 3] =  0;
    //---------------------------------
    m_M4x4ProjectionMatrix[ 4] =  S[1];
    m_M4x4ProjectionMatrix[ 5] =  U[1];
    m_M4x4ProjectionMatrix[ 6] = -F[1];
    m_M4x4ProjectionMatrix[ 7] =  0;
    //---------------------------------
    m_M4x4ProjectionMatrix[ 8] =  S[2];
    m_M4x4ProjectionMatrix[ 9] =  U[2];
    m_M4x4ProjectionMatrix[10] = -F[2];
    m_M4x4ProjectionMatrix[11] =  0;
    //---------------------------------
    m_M4x4ProjectionMatrix[12] =  0;
    m_M4x4ProjectionMatrix[13] =  0;
    m_M4x4ProjectionMatrix[14] =  0;
    m_M4x4ProjectionMatrix[15] =  1;
    //-------------------------------------------
    //*/

    //-----------------------------------------------------
    if ( m_eCameraType == Enum::PERSPECTIVE ) {
        //-----------------------------
        // From OpenGL Ref 2.1
        // | 2near/(right-left)         0               A       0 |
        // |        0           2near/(top-bottom)      B       0 |
        // |        0                   0               C       D |
        // |        0                   0               -1      0 |
        T RpL = m_tRight + m_tLeft;
        T RnL = m_tRight - m_tLeft;
        T TpB = m_tTop + m_tBottom;
        T TnB = m_tTop - m_tBottom;
        T FpN = m_tFar + m_tNear;
        T FnN = m_tFar - m_tNear;

        T A = RpL / RnL;
        T B = TpB / TnB;
        T C = -FpN / FnN;
        T n2 = 2*m_tNear;
        T D = -n2*m_tFar / FnN;
        T E = n2 / RnL;
        T F = n2 / TnB;

        m_M4x4ProjectionMatrix[ 0] = E;
        m_M4x4ProjectionMatrix[ 1] = 0;
        m_M4x4ProjectionMatrix[ 2] = A;
        m_M4x4ProjectionMatrix[ 3] = 0;
        m_M4x4ProjectionMatrix[ 4] = 0;
        m_M4x4ProjectionMatrix[ 5] = F;
        m_M4x4ProjectionMatrix[ 6] = B;
        m_M4x4ProjectionMatrix[ 7] = 0;
        m_M4x4ProjectionMatrix[ 8] = 0;
        m_M4x4ProjectionMatrix[ 9] = 0;
        m_M4x4ProjectionMatrix[10] = C;
        m_M4x4ProjectionMatrix[11] = D;
        m_M4x4ProjectionMatrix[12] = 0;
        m_M4x4ProjectionMatrix[13] = 0;
        m_M4x4ProjectionMatrix[14] = -1;
        m_M4x4ProjectionMatrix[15] = 0;
    }
    else { // for orthogonal view volume
        //-----------------------------
        // From OpenGL Ref 2.1
        // | 2/(right-left)         0               0       A |
        // |        0       2/(top-bottom)          0       B |
        // |        0               0       -2/(far-near)   C |
        // |        0               0               0       1 |
        T RpL = m_tRight + m_tLeft;
        T RnL = m_tRight - m_tLeft;
        T TpB = m_tTop + m_tBottom;
        T TnB = m_tTop - m_tBottom;
        T FpN = m_tFar + m_tNear;
        T FnN = m_tFar - m_tNear;

        T A = -RpL / RnL;
        T B = -TpB / TnB;
        T C = -FpN / FnN;
        T D =  2 / RnL;
        T E =  2 / TnB;
        T F = -2 / FnN;

        m_M4x4ProjectionMatrix[ 0] = D;
        m_M4x4ProjectionMatrix[ 1] = 0;
        m_M4x4ProjectionMatrix[ 2] = 0;
        m_M4x4ProjectionMatrix[ 3] = A;
        m_M4x4ProjectionMatrix[ 4] = 0;
        m_M4x4ProjectionMatrix[ 5] = E;
        m_M4x4ProjectionMatrix[ 6] = 0;
        m_M4x4ProjectionMatrix[ 7] = B;
        m_M4x4ProjectionMatrix[ 8] = 0;
        m_M4x4ProjectionMatrix[ 9] = 0;
        m_M4x4ProjectionMatrix[10] = F;
        m_M4x4ProjectionMatrix[11] = C;
        m_M4x4ProjectionMatrix[12] = 0;
        m_M4x4ProjectionMatrix[13] = 0;
        m_M4x4ProjectionMatrix[14] = 0;
        m_M4x4ProjectionMatrix[15] = 1;
    }

}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetOrthographicViewVolume ()
{
    glMatrixMode( GL_PROJECTION );
    T ratio = static_cast<T>( m_v4iViewport[2] ) / static_cast<T>( m_v4iViewport[3] );
    glLoadIdentity();
    glOrtho(    m_tViewVolumeLeft,      m_tRight, 
                m_tLeft / ratio, m_tRight / ratio, 
//              m_tBottom,  m_tTop, 
                m_tNear,        m_tFar 
    );
}
//-----------------------------------------------------------------------------
template <typename T>
void OpenGLCameraModel<T>::SetPerspectiveViewVolume ()
{
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
//  glFrustum(  m_tViewVolumeLeft,      m_tRight, 
//              m_tBottom,  m_tTop, 
//              m_tNear,        m_tFar 
    //gluPerspective( m_tFOVY, 
    //  // aspect ratio is width/height of viewport
    //  static_cast<T>( m_v4iViewport[2] ) / static_cast<T>( m_v4iViewport[3] ), 
    //  m_tNear, m_tFar
    //);
}
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----