basic/geometry/IGS/IGS_Controller.cpp

Go to the documentation of this file.

#define AUX

#include <assert.h>
#include "IGS_Controller.h"
#include <stdio.h>
#include "opengl/glos.h"
#include <gl/gl.h>
#include <gl/glu.h>
#ifndef NOAUX
        #include <gl/glaux.h>
#endif
#include "synchronization/guid.h"
#include "synchronization/semaphore.h"

int gGlGuid = GuidGenerator::GenerateNewGuid();
Semaphore gGlSemaphore( gGlGuid );

float gDefaultClearR = 0.8f;
float gDefaultClearG = 0.8f;
float gDefaultClearB = 1.0f;
float gDefaultClearA = 1.0f;


//=============================================================================
// Constructor
//
// Description: constructor
//=============================================================================
IGS_Controller::IGS_Controller():
        mCameraEye( 0, 0, 1 ),
        mCameraTarget( 0, 0, 0 ),
        mCameraUp( 0, 1, 0 ),
        mColorDefault( NULL ),
        mFrameNumber( 0 ),
        mGlClearBits( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ),
        mHdc( NULL ),
        mHwnd( NULL ),
        mSettingAlphaBlendingOn( true ),
        mSettingAnimationOn( true ),
        m_SettingAntiAliasingOn( true ),
        mSettingDebugMessageLevel( 0 ),
        mSettingDepthTestingOn( true ),
        mSettingDoubleBufferingOn( true ),
        mSettingLightingEnabled( false ),
        mSettingNormalsRelativeToCamera( true ),
        m_SettingPointSize( 5.0 ),
        mSettingRenderNormals( false ),
        mSettingRenderNormalsAsColors( false ),
        mSettingRenderSilhouettes( true ),
        mSettingRenderStyle( G_COLOR ),
        mSettingShadingModel( GL_SMOOTH ),                      //GL_FLAT/GL_SMOOTH     
        mSettingSilhouetteEdgeWidth( 2.0 ),
        mSettingTexturingOn( false ),
        m_SettingWindowXmin( -0.1 ),
        m_SettingWindowXmax( 1.1 ),
        m_SettingWindowYmin( -0.1 ),
        m_SettingWindowYmax( 1.1 ),
    m_SettingWindowZmin( -1000.0 ),
    m_SettingWindowZmax( 1000.0 ),
        mStateScreenCaptureDone( false ),
        mWindowResolutionX( 100 ),
        mWindowResolutionY( 100 )
{
        //make sure this style gets applied
        this->SetRenderStyle( this->mSettingRenderStyle );

        //set up the G buffers for capture
        mGbufferColor.SetFormat( GL_RGB );
        mGbufferDepth.SetFormat( GL_DEPTH );

        //set up the sizes of the G buffers
        mGbufferColor.SetResolution( this->mWindowResolutionX, this->mWindowResolutionY );
        mGbufferDepth.SetResolution( this->mWindowResolutionX, this->mWindowResolutionY );

        //set up the default color
        this->mColorDefault = new unsigned char[ 3 ];
        mColorDefault[ 0 ] = 255;
        mColorDefault[ 1 ] = 255;
        mColorDefault[ 2 ] = 255;

        //set up the clear color
        mColorClear[ 0 ] = gDefaultClearR;
        mColorClear[ 1 ] = gDefaultClearG;
        mColorClear[ 2 ] = gDefaultClearB;
        mColorClear[ 3 ] = gDefaultClearA;
}

//=============================================================================
// Destructor
//
// Description: Destructor
//=============================================================================
IGS_Controller::~IGS_Controller()
{
        delete[] this->mColorDefault;
}

//=============================================================================
// BeginFrame
//
// Description: called when the frame is initialized
//=============================================================================
void IGS_Controller::BeginFrame() const
{
//      ::gGlSemaphore.Lock();

        static int frameCount = 0;
        frameCount++;
        GLenum errorcode = glGetError();
        //assert( errorcode == GL_NO_ERROR );


#ifdef NOAUX
        // make it the calling thread's current rendering context
        this->mHdc = ::GetDC( this->mHwnd );
        static bool alreadyCurrent = false;
        if( !alreadyCurrent )
        {
                BOOL success = wglMakeCurrent ( this->mHdc, this->mHglrc ); // call OpenGL APIs as desired ... 
                assert( success != FALSE ) ;
                alreadyCurrent = true;
        }

#endif

        this->mFrameNumber++;
        if( mSettingDebugMessageLevel > 0 )
        {
                ::printf( "Beginning Frame %d\n", this->FrameNumber() );
        }

        //get the dimensions of the window
        ::glViewport( 0, 0, mWindowResolutionX, mWindowResolutionY );
        errorcode = ::glGetError();
        IJG_Assert( errorcode == GL_NO_ERROR );

        //do the camera stuff
    ::glMatrixMode( GL_PROJECTION );
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

    ::glLoadIdentity();
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glOrtho( m_SettingWindowXmin, m_SettingWindowXmax, m_SettingWindowYmin, m_SettingWindowYmax, m_SettingWindowZmin, m_SettingWindowZmax );      //watch the near/far clip plane carefilly
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glMatrixMode( GL_MODELVIEW );
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glLoadIdentity();
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::gluLookAt
        ( 
                this->mCameraEye[ 0 ], this->mCameraEye[ 1 ], this->mCameraEye[ 2 ],
                this->mCameraTarget[ 0 ], this->mCameraTarget[ 1 ], this->mCameraTarget[ 2 ],
                this->mCameraUp[ 0 ], this->mCameraUp[ 1 ], this->mCameraUp[ 2 ]
        );
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glShadeModel( this->mSettingShadingModel );
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        //enable alpha blending
        if( this->mSettingAlphaBlendingOn == true )
        {
                ::glEnable( GL_BLEND );
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );

                glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );
        }
        else
        {
                ::glDisable( GL_BLEND );
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );
        }

        //enable depth testing
        if( mSettingDepthTestingOn )
        {
                ::glEnable( GL_DEPTH_TEST );
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );

                ::glDepthFunc( GL_LEQUAL );
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );
        }
        else
        {
                ::glDisable( GL_DEPTH_TEST );
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );
        }

        //enable texturing
        if( this->mSettingTexturingOn == true )
        {
                ::glEnable( GL_TEXTURE_2D );
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );
        }
        else
        {
                ::glDisable( GL_TEXTURE_2D );
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );
        }

        glClearColor
        ( 
                this->mColorClear[ 0 ], 
                this->mColorClear[ 1 ], 
                this->mColorClear[ 2 ], 
                this->mColorClear[ 3 ] 
        );
        ::glClear( this->mGlClearBits );
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        ::glColor3ubv( this->mColorDefault );
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );

        //do the lighting
        this->DoLighting();

        //set the point size
        ::glPointSize( m_SettingPointSize );

        if( m_SettingAntiAliasingOn == true )
        {
                ::glEnable( GL_POINT_SMOOTH );
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );

                ::glEnable( GL_LINE_SMOOTH );
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );
        }
}

//=============================================================================
// ConvertMouseClick
//
// Description: converts a mouse click into a line segment for picking 
//=============================================================================
Segment IGS_Controller::ConvertMouseClick( const int x, const int y ) const
{
    //
    // Figure out the window extents from the hwnd
    //
    RECT rect;
    GetWindowRect( mHwnd, &rect );

    //
    // Get [x,y] offsets from lower left corner
    //
    int xOffset = x;
    int yOffset = ( rect.bottom - rect.top ) - y;
    double xPercent = xOffset / double( mWindowResolutionX );
    double yPercent = yOffset / double( mWindowResolutionY );
    double xPos = xPercent * ( m_SettingWindowXmax - m_SettingWindowXmin ) + m_SettingWindowXmin;
    double yPos = yPercent * ( m_SettingWindowYmax - m_SettingWindowYmin ) + m_SettingWindowYmin;
    Segment returnMe( mCameraEye, Vector4( xPos, yPos, 0 ) );
    return returnMe;
}

//=============================================================================
// CreateWindow
//
// Description: initializes the window using glAux - this is good for command 
//                              line only
//=============================================================================
#ifndef NOAUX
void IGS_Controller::CreateInitialWindow() const
{
        // Double Buffer & RGB 
        if( this->mSettingDoubleBufferingOn == true )
        {
                auxInitDisplayMode (AUX_DOUBLE | AUX_RGB );
        }
        else
        {
                auxInitDisplayMode ( AUX_RGB );
        }
        
        // Size of the window
    auxInitPosition( 0, 0, this->mWindowResolutionX, this->mWindowResolutionY );
        auxInitWindow ("VRML Loader");
}
#endif

//=============================================================================
// DoLighting
//
// Description: performs any frame dependant lighting enabling/disabling
//=============================================================================
void IGS_Controller::DoLighting() const
{
        if( this->mSettingLightingEnabled == true )
        {
                //IAN IMPROVE: it's probably inefficient to call this every frame
                ::glEnable( GL_LIGHTING );
                ::glEnable( GL_LIGHT0 );
                ::glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, 1 );
                float ambient[] = { 1.0, 0.0, 0.0 };
                glLightfv( GL_LIGHT0, GL_AMBIENT, ambient );

                //setup the default material properties
                float mAmbient[] =      { 0.2f, 0.2f, 0.2f, 1.0f };
                float mDiffuse[] =      { 0.8f, 0.8f, 0.8f, 1.0f };
                float mSpecular[] = { 0.2f, 0.2f, 0.2f, 1.0f };
                glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, mAmbient );
                glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, mAmbient );
                glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, mSpecular );
                glMaterialf(  GL_FRONT_AND_BACK, GL_SHININESS, 5.0 );
                
                
        }
        else
        {
                ::glDisable( GL_LIGHTING );
        }
}

//=============================================================================
// EndFrame
//
// Description: swaps the buffers and cleans up the frame
//=============================================================================
void IGS_Controller::EndFrame() const
{
        if( this->mSettingDoubleBufferingOn == true )
        {
                #ifndef NOAUX
                auxSwapBuffers(); 
                #else
                //TRACE( "Swapping Buffers\n" );
                BOOL swapSuccess = wglSwapLayerBuffers( this->mHdc, WGL_SWAP_MAIN_PLANE );
                assert( swapSuccess == TRUE );
                #endif
        }

        if( this->mSettingAnimationOn == true )
        {
                HWND handle = NULL;
                #ifndef NOAUX
                handle =  auxGetHWND();
                #else
                handle = this->mHwnd;
                #endif  
                ::InvalidateRect( handle, NULL, FALSE );
        }

#ifdef NOAUX
        // make it the calling thread's current rendering context
        ::ReleaseDC( this->mHwnd, this->mHdc );
        this->mHdc = NULL;
#endif

        if( mSettingDebugMessageLevel > 0 )
        {
                ::printf( "Ending Frame %d\n", this->FrameNumber() );
        }
//      ::gGlSemaphore.Unlock();

        GLenum errorcode;
        errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );
}

//=============================================================================
// FrameNumber
//
// Description: returns the value of the current frame number
//=============================================================================
unsigned int IGS_Controller::FrameNumber() const
{
        return this->mFrameNumber;
}

//=============================================================================
// GetCameraDirection
//
// Description: returns the camera direction for silhouette edge detection
//=============================================================================
Vector4 IGS_Controller::GetCameraDirection() const
{
        return ( this->mCameraEye - this->mCameraTarget );
}

//=============================================================================
// FrameNumber
//
// Description: returns the value of the current frame number
//=============================================================================
enumGBufferTypes IGS_Controller::GetRenderStyle() const
{
        return this->mSettingRenderStyle;
}

//=============================================================================
// GetSilhouetteEdgeWidth
//
// Description: returns the value of the silhouette edge width
//=============================================================================
float IGS_Controller::GetSilhouetteEdgeWidth() const
{
        return this->mSettingSilhouetteEdgeWidth;
}

//=============================================================================
// GetWindowXMax
//
// Description: returns the value of the window extents
//=============================================================================
double IGS_Controller::GetWindowXMax() const
{
        return this->m_SettingWindowXmax;
}

//=============================================================================
// GetWindowXMin
//
// Description: returns the value of the window extents
//=============================================================================
double IGS_Controller::GetWindowXMin() const
{
        return this->m_SettingWindowXmin;
}

//=============================================================================
// GetWindowYMax
//
// Description: returns the value of the window extents
//=============================================================================
double IGS_Controller::GetWindowYMax() const
{
        return this->m_SettingWindowYmax;
}

//=============================================================================
// GetWindowXMax
//
// Description: returns the value of the window extents
//=============================================================================
double IGS_Controller::GetWindowYMin() const
{
        return this->m_SettingWindowYmin;
}

//=============================================================================
// Process
//
// Description: returns the value of the current frame number
//=============================================================================
void IGS_Controller::Process()
{
        assert( false );
}

//=============================================================================
// ScreenCapture
//
// Description: performs a screen capture, and outputs it to disk
//=============================================================================
void IGS_Controller::RegisterInitialWindow( HWND hwnd )
{
        this->mHwnd = hwnd;
    PIXELFORMATDESCRIPTOR pfd =
    {
       sizeof( PIXELFORMATDESCRIPTOR ), // Structure size.
        1,                             // Structure version number.
        PFD_DRAW_TO_WINDOW |           // Property flags.
        PFD_DOUBLEBUFFER |
                PFD_SUPPORT_OPENGL |
                PFD_GENERIC_ACCELERATED |
//              PFD_GENERIC_FORMAT,
        PFD_TYPE_RGBA,
        24,                          // 24-bit color.
        0, 0, 0, 0, 0, 0,              // Not concerned with these.
        0, 0, 0, 0, 0, 0, 0,           // No alpha or accum buffer.
        32,                            // 32-bit depth buffer.
        0, 0,                          // No stencil or aux buffer.
        PFD_MAIN_PLANE,                // Main layer type.
        0,                             // Reserved.
        0, 0, 0                        // Unsupported.
    };

        HDC cdc = ::GetDC( hwnd );
        assert( cdc != NULL );

    int pixelFormat = ::ChoosePixelFormat( cdc, &pfd );
        assert( pixelFormat != 0 );

    BOOL success = ::SetPixelFormat( cdc, pixelFormat, &pfd );  
        assert( success == TRUE );

        mHglrc = ::wglCreateContext ( cdc );  
        assert( mHglrc != NULL ) ;

        int result = ::ReleaseDC( hwnd, cdc ) ;
        assert( result == 1 );
}

//=============================================================================
// ScreenCapture
//
// Description: performs a screen capture, and outputs it to disk
//=============================================================================
void IGS_Controller::ScreenCapture()
{
#ifdef NOAUX
        this->mHdc = ::GetDC( this->mHwnd );
        BOOL success = wglMakeCurrent ( this->mHdc, this->mHglrc ); // call OpenGL APIs as desired ... 
//      if( success == FALSE )
//      {
//              return ;
//      }
        assert( success != FALSE ) ;
#endif

        //capture ColorBuffer
        this->mGbufferColor.ScreenCapture();
        this->mGbufferDepth.ScreenCapture();
        this->mStateScreenCaptureDone = true;
}

//=============================================================================
// SetCameraLookat
//
// Description: allows you to set the camera's target point
//=============================================================================
void IGS_Controller::SetCameraLookat( const Vector4& vector )
{
        this->mCameraTarget = vector;
}

//=============================================================================
// SetCameraPosition
//
// Description: allows you to set the camera's position
//=============================================================================
void IGS_Controller::SetCameraPosition( const Vector4& vector )
{
        this->mCameraEye = vector;
}

//=============================================================================
// SetClearColor
//
// Description: changes the color used to clear the screen
//=============================================================================
void IGS_Controller::SetClearColor( IGS_Color& color )
{
        this->mColorClear[ 0 ] = color.r;
        this->mColorClear[ 1 ] = color.g;
        this->mColorClear[ 2 ] = color.b;
        this->mColorClear[ 3 ] = 1.0;
}

//=============================================================================
// SetRenderSilhouettes
//
// Description: turns on/off silhouette rendering
//=============================================================================
void IGS_Controller::SetRenderSilhouettes( bool onOff )
{
        this->mSettingRenderSilhouettes = onOff;
}

//=============================================================================
// SetRenderStyle
//
// Description: Sets a particular rendering style
//=============================================================================
void IGS_Controller::SetRenderStyle( enumGBufferTypes style )
{
        this->mSettingRenderStyle = style;

        //set all settings to off
        this->mSettingLightingEnabled = false;
        this->mSettingRenderNormals = false;
        this->mSettingRenderNormalsAsColors = false;
        this->mSettingNormalsRelativeToCamera = false;

        this->mColorClear[ 0 ] = gDefaultClearR;
        this->mColorClear[ 1 ] = gDefaultClearG;
        this->mColorClear[ 2 ] = gDefaultClearB;
        this->mColorClear[ 3 ] = gDefaultClearA;

        switch( style )
        {
        case G_PHOTOREALISTIC:
                {
                        this->mSettingLightingEnabled = true;
                        this->mSettingRenderNormals = true;
                        break;
                }
        case G_COLOR:
                {
                        break;
                }
        case G_DEPTH:
                {
                        break;
                }
        case G_NORMAL:
                {
                        this->mSettingRenderNormalsAsColors = true;
                        break;
                }
        case G_NORMAL_WRT_CAMERA:
                {
                        this->mSettingRenderNormalsAsColors = true;
                        this->mSettingNormalsRelativeToCamera = true;
                        break;
                }
        case G_UV:
                {
                        break;
                }
        case G_SILHOUETTE_ONLY:
                {
                        this->mColorDefault[ 0 ] = 255;
                        this->mColorDefault[ 1 ] = 255;
                        this->mColorDefault[ 2 ] = 255;
                        this->mColorDefault[ 3 ] = 255;

                        this->mColorClear[ 0 ] = 1.0;
                        this->mColorClear[ 1 ] = 1.0;
                        this->mColorClear[ 2 ] = 1.0;
                        this->mColorClear[ 3 ] = 1.0;

                        break;
                }
        default:
                {
                        assert( false );
                        break;
                }
        }
}
//=============================================================================
// SetSilhouetteEdgeWidth
//
// Description: sets the width of silhouette edges
//=============================================================================
void IGS_Controller::SetSilhouetteEdgeWidth( const float width )
{
        this->mSettingSilhouetteEdgeWidth = width;
}

//=============================================================================
// SettingLightingEnabled
//
// Description: returns the value of the lighting enabled setting
//=============================================================================
bool IGS_Controller::SettingLightingEnabled() const
{
        return this->mSettingLightingEnabled;
}

//=============================================================================
// SettingRenderNormals
//
// Description: returns the value of the render normals setting
//=============================================================================
bool IGS_Controller::SettingNormalsRelativeToCamera() const
{
        return this->mSettingNormalsRelativeToCamera;
}

//=============================================================================
// SettingRenderNormals
//
// Description: returns the value of the render normals setting
//=============================================================================
bool IGS_Controller::SettingRenderNormals() const
{
        return this->mSettingRenderNormals;
}

//=============================================================================
// SettingRenderNormals
//
// Description: returns the value of the render normals setting
//=============================================================================
bool IGS_Controller::SettingRenderNormalsAsColors() const
{
        return this->mSettingRenderNormalsAsColors;
}

//=============================================================================
// SettingRenderSilhouettes
//
// Description: returns the value of the render silhouettes setting
//=============================================================================
bool IGS_Controller::SettingRenderSilhouettes() const
{
        return this->mSettingRenderSilhouettes;
}

void IGS_Controller::SetWindowRect
( 
        const double xMin, 
        const double xMax, 
        const double yMin, 
        const double yMax,
        const double zMin,
        const double zMax
)
{
        this->m_SettingWindowXmin = xMin;
        this->m_SettingWindowXmax = xMax;
        this->m_SettingWindowYmin = yMin;
        this->m_SettingWindowYmax = yMax;
        this->m_SettingWindowZmin = zMin;
        this->m_SettingWindowZmax = zMax;
}

//=============================================================================
// SetWindowResolution
//
// Description: returns the value of the render normals setting
//=============================================================================
void IGS_Controller::SetWindowResolution( const int xres, const int yres )
{
        this->mWindowResolutionX = xres;
        this->mWindowResolutionY = yres;

        //set up the sizes of the G buffers
        mGbufferColor.SetResolution( this->mWindowResolutionX, this->mWindowResolutionY );
        mGbufferDepth.SetResolution( this->mWindowResolutionX, this->mWindowResolutionY );
}

---