TAPsOpenGLViewManager.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsOpenGLViewManager.cpp

Inherited from class OpenGLBaseViewManager

SUKITTI PUNAK   (07/20/2005)
UPDATE          (07/30/2005)
******************************************************************************/
#include "TAPsOpenGLViewManager.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.

//-----------------------------------------------------------------------------
// DEBUG ENABLE
#ifdef TAPs_ENABLE_DEBUG
    #define DEBUG_MESSAGE_TAPs_VIEW_MANAGER
#endif
//-----------------------------------------------------------------------------
BEGIN_NAMESPACE_TAPs__OpenGL
//=============================================================================
//-----------------------------------------------------------------------------
// Default Constructor
template <typename T>
OpenGLViewManager<T>::OpenGLViewManager ()
    : OpenGLBaseViewManager<T>(),
      m_tViewScale( 1 ),
      m_tWindowToWorldScale( 1 ),
      m_iLastMouseX( 0 ),
      m_iLastMouseY( 0 ),
      m_vLookAt( 0, 0, 0 ),
      m_eModifyViewType( INVALID_MODIFY_VIEW )
{}
//-----------------------------------------------------------------------------
// Destructor
template <typename T>
OpenGLViewManager<T>::~OpenGLViewManager ()
{}
//-----------------------------------------------------------------------------
// Setup OpenGL Rendering Properties
template <typename T>
void OpenGLViewManager<T>::Setup ()
{
    // Enable depth buffering for hidden surface removal
    glDepthFunc( GL_LEQUAL );
    glEnable( GL_DEPTH_TEST );
    // Cull back faces
    glCullFace( GL_BACK );
    glEnable( GL_CULL_FACE );
    // Other misc features
    glEnable( GL_LIGHTING );
    glEnable( GL_NORMALIZE );
    glShadeModel( GL_SMOOTH );
    glLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE );
    glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE );
    static const GLfloat light_model_ambient[] = { 0.3f, 0.3f, 0.3f, 1.0f };
    glLightModelfv( GL_LIGHT_MODEL_AMBIENT, light_model_ambient );
    //*
    TAPs::OpenGL::Fn::InitializeLight( GL_LIGHT0, 
            0.3f, 0.3f, 0.3f, 1.0f,     // ambient
            0.7f, 0.7f, 0.7f, 0.9f,     // diffuse
            0.9f, 0.9f, 0.9f, 0.5f,     // specular
            0.0f, 0.4f, 10.0f, 1.0f     // position
    );
    //*/
    /*
    TAPs::OpenGL::Fn::InitializeLight( GL_LIGHT1, 
            0.5f, 0.5f, 0.5f, 1.0f,     // ambient
            0.8f, 0.8f, 0.8f, 0.9f,     // diffuse
            1.0f, 1.0f, 1.0f, 1.0f,     // specular
            2.0f, 0.0f, 1.0f, 0.0f      // position
    );
    //*/
    /*
    TAPs::OpenGL::Fn::InitializeLight( GL_LIGHT2, 
            0.3f, 0.3f, 0.3f, 1.0f,     // ambient
            0.4f, 0.4f, 0.4f, 0.9f,     // diffuse
            0.5f, 0.5f, 0.5f, 0.5f,     // specular
            -2.0f, 0.0f, 1.0f, 0.0f     // position
    );
    //*/
}
//-----------------------------------------------------------------------------
// Cleanup
template <typename T>
void OpenGLViewManager<T>::Cleanup ()
{}
//-----------------------------------------------------------------------------
// ReshapeView
template <typename T>
void OpenGLViewManager<T>::ReshapeView ( int width, int height )
{
    static const T K_FOV_Y = 40;
    static const T K_CANONICAL_SPHERE_RADIUS = sqrt( static_cast<T>(3.0) );
    static const T K_PI = 3.1415926535897932384626433832795;
    //-------------------------------------------------------------------
    glViewport( 0, 0, static_cast<GLsizei>(width), static_cast<GLsizei>(height) );
    //-------------------------------------------------------------------
    // Compute the viewing parameters based on a fixed fov and viewing
    // sphere enclosing a canonical box centered at the origin
    T nearDist = K_CANONICAL_SPHERE_RADIUS / tan( (K_FOV_Y/2.0) * K_PI / 180.0 );
    T farDist  = nearDist + 2.0 * K_CANONICAL_SPHERE_RADIUS;
    //T nearDist = 1;
    //T farDist  = 100;
    //std::cout << "nearDist: " << nearDist << " farDist: " << farDist << std::endl;
    T aspect   = static_cast<T>(width) / static_cast<T>(height);
    //-------------------------------------------------------------------
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective( K_FOV_Y, aspect, nearDist, farDist );
    //-------------------------------------------------------------------
    // View down the z-axis and look at the origin
    m_vViewPosition[0] = 0;
    m_vViewPosition[1] = 0;
    m_vViewPosition[2] = nearDist + K_CANONICAL_SPHERE_RADIUS;
    UpdateView();
}
//-----------------------------------------------------------------------------
// UpdateView
template <typename T> 
void OpenGLViewManager<T>::UpdateView ()
{
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    gluLookAt(  m_vViewPosition[0], m_vViewPosition[1], m_vViewPosition[2],
                m_vLookAt[0], m_vLookAt[1], m_vLookAt[2],
                0, 1, 0 );
    glMultMatrixd( m_mViewRotation );
    glScaled( m_tViewScale, m_tViewScale, m_tViewScale );
    //----------------------------------------------------------------
    // Refresh the cache of OpenGL view state
    glGetDoublev( GL_MODELVIEW_MATRIX, m_mWorldToView );
    glGetDoublev( GL_PROJECTION_MATRIX, m_mViewToClip );
    glGetIntegerv( GL_VIEWPORT, m_aiViewport );
    UpdateWindowToWorldScale();
}
//-----------------------------------------------------------------------------
// IsModifyingView
template <typename T>
bool OpenGLViewManager<T>::IsModifyingView () const
{
    return m_eModifyViewType != INVALID_MODIFY_VIEW;
}
//-----------------------------------------------------------------------------
// StartModifyView
template <typename T>
void OpenGLViewManager<T>::StartModifyView ( enum ModifyViewType type, int x, int y )
{
    if ( type == MODIFY_VIEW_ROTATE || type == MODIFY_VIEW_SCALE ) {
        m_eModifyViewType = type;
        m_iLastMouseX = x;
        m_iLastMouseY = y;
    }
}
//-----------------------------------------------------------------------------
// StopModifyView
template <typename T>
void OpenGLViewManager<T>::StopModifyView ()
{
    m_eModifyViewType = INVALID_MODIFY_VIEW;
}
//-----------------------------------------------------------------------------
// ModifyView
template <typename T>
void OpenGLViewManager<T>::ModifyView ( int x, int y )
{
    static const T K_TRACK_BALL_RADIUS = 0.8;
    //----------------------------------------------------------------
    if ( m_eModifyViewType == MODIFY_VIEW_ROTATE ) {
        Vector3<T> lastPos;
        lastPos[0] = 2.0*m_iLastMouseX/GetWindowWidth() - 1.0;
        lastPos[1] = 2.0*(GetWindowHeight() - m_iLastMouseY)/GetWindowHeight() - 1.0;
        lastPos[2] = ProjectToTrackBall( K_TRACK_BALL_RADIUS, lastPos[0], lastPos[1] );
        //------------------------------------------------------
        Vector3<T> currPos;
        currPos[0] = 2.0*x/GetWindowWidth() - 1.0;
        currPos[1] = 2.0*(GetWindowHeight() - y)/GetWindowHeight() - 1.0;
        currPos[2] = ProjectToTrackBall( K_TRACK_BALL_RADIUS, currPos[0], currPos[1] );
        //------------------------------------------------------
        Vector3<T> vRotate = lastPos.Cross( currPos );
        T rotateAngle = asin( vRotate.Length() );
        if ( fabs( rotateAngle - 0.0 ) > Math<T>::EPSILON ) {
            Matrix4x4<T> deltaRotation = Matrix4x4<T>::CreateRotation( vRotate, rotateAngle ).GetTranspose();
            m_mViewRotation.MultRight( deltaRotation );
            UpdateView();
        }
    }
    //----------------------------------------------------------------
    else if ( m_eModifyViewType == MODIFY_VIEW_SCALE ) {
        T y1 = GetWindowHeight() - m_iLastMouseY;
        T y2 = GetWindowHeight() - y;
        m_tViewScale *= 1 + (y1 - y2) / GetWindowHeight();
        UpdateView();
    }
    m_iLastMouseX = x;
    m_iLastMouseY = y;
}
//-----------------------------------------------------------------------------
// ToScreen
template <typename T>
bool OpenGLViewManager<T>::ToScreen ( const Vector3<T> & obj, Vector3<T> & win ) const
{
    int iResult = gluProject(   obj[0], obj[1], obj[2],
                                m_mWorldToView,     // m_mWorldToView matrix
                                m_mViewToClip,      // projection matrix
                                m_aiViewport,       // viewport
                                &win[0], &win[1], &win[2] );
    return iResult == GL_TRUE;
}
//-----------------------------------------------------------------------------
// FromScreen
template <typename T>
bool OpenGLViewManager<T>::FromScreen ( const Vector3<T> & win, Vector3<T> & obj ) const
{
    int iResult = gluUnProject( win[0], win[1], win[2],
                                m_mWorldToView,     // m_mWorldToView matrix
                                m_mViewToClip,      // projection matrix 
                                m_aiViewport,       // viewport
                                &obj[0], &obj[1], &obj[2] );
    return iResult == GL_TRUE;
}
//-----------------------------------------------------------------------------
// GetWindowToWorldScale
template <typename T>
T OpenGLViewManager<T>::GetWindowToWorldScale () const
{
    return m_tWindowToWorldScale;
}
//-----------------------------------------------------------------------------
// GetViewTransform
template <typename T>
const Matrix4x4<T> & OpenGLViewManager<T>::GetViewTransform () const
{
    return m_mWorldToView;
}
//-----------------------------------------------------------------------------
// GetProjTransform
template <typename T>
const Matrix4x4<T> & OpenGLViewManager<T>::GetProjTransform () const
{
    return m_mViewToClip;
}
//-----------------------------------------------------------------------------
//=============================================================================
// Helper Fn
//-----------------------------------------------------------------------------
// ProjectToTrackBall
// used by the view rotation code for simulating a virtual trackball.
// This math computes the z height for a 2D projection onto the surface of a 
// 2.5D sphere.  When the input point is near the center of the sphere, it 
// computes the actual sphere intersection in Z.  When the input point is moved 
// towards the outside of the sphere, it will solve for a hyperbolic projection, 
// so that we still get a meaningful answer.
template <typename T>
T OpenGLViewManager<T>::ProjectToTrackBall ( T radius, T x, T y )
{
    static const T K_UINT_SPHERE_RADIUS_2D = sqrt( 2.0 );
    T z;
    T dist = sqrt( x*x + y*y );
    if ( dist < radius * K_UINT_SPHERE_RADIUS_2D / 2.0 ) {
        // Solve for sphere case
        z = sqrt( radius*radius - dist*dist );
    }
    else {
        // Solve for hyperbolic sheet case
        T t = radius / K_UINT_SPHERE_RADIUS_2D;
        z = t*t / dist;
    }
    return z;
}
//-----------------------------------------------------------------------------
// UpdateWindowToWorldScale
// uses the viewing transforms to determine a scale factor that will allow us to 
// specify the size of objects on the screen in pixel dimensions.
template <typename T>
void OpenGLViewManager<T>::UpdateWindowToWorldScale ()
{
    Vector3<T> p0, p1;
    bool bNoError;
    bNoError = FromScreen( Vector3<T>(0,0,0), p0 );
    assert( bNoError );
    bNoError = FromScreen( Vector3<T>(1,1,0), p1 );
    assert( bNoError );
    m_tWindowToWorldScale = (p1-p0).Length() / sqrt(2.0);
}
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8