TAPsOpenGLObj.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsOpenGLObj.cpp

OpenGLObj class (cpp file).

SUKITTI PUNAK   (08/14/2009)
******************************************************************************/
#include "TAPsOpenGLObj.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
//=============================================================================
char        OpenGLObj::m_GL_Version[3]          = {-1,-1,-1};
std::string OpenGLObj::m_GL_TAPsResourcePath    = "";
//=============================================================================
// Constructors
//-----------------------------------------------------------------------------
OpenGLObj::OpenGLObj ()
{
    InitOnce();
}
//-----------------------------------------------------------------------------
OpenGLObj::OpenGLObj ( OpenGLObj const &orig )
{
    Material = orig.Material;
}
//-----------------------------------------------------------------------------
OpenGLObj::~OpenGLObj ()
{
    #ifdef  TAPs_USE_GLSL
        ClearShaders();
    #endif//TAPs_USE_GLSL

    #ifdef  TAPs_USE_WXWIDGETS
        ClearTextures();
    #endif//TAPs_USE_WXWIDGETS
}
//-----------------------------------------------------------------------------
std::string OpenGLObj::StrInfo () const
{
    std::ostringstream ss;
    ss << "-----<<<<< OpenGLObj >>>>>-----";
    ss << "\n---<<< Material >>>---\n" << Material;
    ss << "\n---<<< Texture >>>---\n" << Texture;
    ss << "\n";
    return ss.str();
}
//-----------------------------------------------------------------------------
//=============================================================================
// Assignment Operator
//-----------------------------------------------------------------------------
OpenGLObj & OpenGLObj::operator= ( OpenGLObj const &orig )
{   
    Material = orig.Material;
    return *this;
}
//-----------------------------------------------------------------------------
//=============================================================================
// Draw
//-----------------------------------------------------------------------------
void OpenGLObj::Draw () const
{   
    //???
}
//-----------------------------------------------------------------------------
//=============================================================================
// Check OpenGL version
//-----------------------------------------------------------------------------
bool OpenGLObj::InitOnce ()
{   
    if      ( m_GL_Version[0] > 0 )     return true;
    else if ( m_GL_Version[0] == 0 )    return false;

    SetTAPsResourcePath();

    m_GL_Version[0] = 0;  m_GL_Version[1] = 0;  m_GL_Version[2] = 0;

    #ifdef  TAPs_USE_GLSL
        GLenum err = glewInit();
        if ( GLEW_OK != err )
        {
            // Problem: glewInit failed
            std::cerr << "Error (FILE:"<<__FILE__<<"; LINE:"<<__LINE__<<"): OpenGL is not supported (" << glewGetErrorString(err) << ")!" << std::endl;
            return false;
        }
        std::cout << "Status: Using GLEW " << glewGetString(GLEW_VERSION) << "\n";
        if (GLEW_VERSION_1_5)   {
            std::cout << "OpenGL Version 1.5 is supported.\n";
            m_GL_Version[0] = 1;  m_GL_Version[1] = 5;  m_GL_Version[2] = 0;
        }
        else    {
            std::cout << "OpenGL Version 1.5 is NOT supported.\n";
        }
        if (GLEW_VERSION_2_0)   {
            std::cout << "OpenGL Version 2.0 is supported.\n";
            m_GL_Version[0] = 2;  m_GL_Version[1] = 0;  m_GL_Version[2] = 0;
        }
        else    {
            std::cout << "OpenGL Version 2.0 is NOT supported.\n";
        }
        if (GLEW_VERSION_2_1)   {
            std::cout << "OpenGL Version 2.1 is supported.\n";
            m_GL_Version[0] = 2;  m_GL_Version[1] = 1;  m_GL_Version[2] = 0;
        }
        else    {
            std::cout << "OpenGL Version 2.1 is NOT supported.\n";
        }
        if (GLEW_VERSION_3_0)   {
            std::cout << "OpenGL Version 3.0 is supported.\n";
            m_GL_Version[0] = 3;  m_GL_Version[1] = 0;  m_GL_Version[2] = 0;
        }
        else    {
            std::cout << "OpenGL Version 3.0 is NOT supported.\n";
        }
        if (GLEW_VERSION_3_1)   {
            std::cout << "OpenGL Version 3.1 is supported.\n";
            m_GL_Version[0] = 3;  m_GL_Version[1] = 1;  m_GL_Version[2] = 0;
        }
        else {
            std::cout << "OpenGL Version 3.1 is NOT supported.\n";
        }
        if (GLEW_VERSION_3_2)   {
            std::cout << "OpenGL Version 3.2 is supported.\n";
            m_GL_Version[0] = 3;  m_GL_Version[1] = 2;  m_GL_Version[2] = 0;
        }
        else {
            std::cout << "OpenGL Version 3.2 is NOT supported.\n";
        }

    #else //TAPs_USE_GLSL
        const GLubyte * glVersion = glGetString(GL_VERSION);
        if ( glVersion != NULL ) {
            std::string version( "" );
            int i = 0;
            while ( glVersion[i] != NULL ) {
                version += glVersion[i++];
            }
            int dot1 = version.find_first_of( "." );
            int dot2 = version.find_last_of( "." );
            m_GL_Version[0] = atoi( version.substr(0, dot1).c_str() );
            m_GL_Version[1] = atoi( version.substr(dot1+1, dot2-dot1-1).c_str() );
            m_GL_Version[2] = atoi( version.substr(dot2+1, version.length()-dot2-1).c_str() );
            std::cout << "OpenGL Version: " << static_cast<int>(m_GL_Version[0]) << "." 
                                            << static_cast<int>(m_GL_Version[1]) << "." 
                                            << static_cast<int>(m_GL_Version[2]) << "\n";
        }
        else {
            std::cout << "OpenGL is not supported!\n";
        }
    #endif//TAPs_USE_GLSL

    if ( m_GL_Version[0] > 0 )  return true;
    else                        return false;
}
//=============================================================================
// Set the path to TAPs resource
//-----------------------------------------------------------------------------
void OpenGLObj::SetTAPsResourcePath ()
{
    // Look for the path in the environment variable named "TAPsResource".
    char * TAPsResourcePath = getenv( "TAPsResource" );
    if ( TAPsResourcePath ) {
        m_GL_TAPsResourcePath += TAPsResourcePath + std::string("/");
    }
    else {  // If "TAPsResource" doesn't exist, then use this path.
        m_GL_TAPsResourcePath = "TAPsResource/";
    }
    //std::cout << "The path to TAPs resource: " << m_GL_TAPsResourcePath << "\n";
}
//-----------------------------------------------------------------------------


//=============================================================================
#ifdef  TAPs_USE_GLSL
//-----------------------------------------------------------------------------
// Initialize shaders
bool OpenGLObj::InitShaders (
    std::string const & shaderFileName,     
    bool useVertexShader,                   
    bool useGeometryShader,                 
    bool useFragmentShader                  
)
{
    // Create a GLSL manager
    if ( !glslManager.CreateGLSLProgramObject( glslProgObj ) ) {
        std::cout << "Error ("<<__FILE__<<";"<<__LINE__<<"): GLSL couldn't create a glsl program object!" << std::endl;
        return false;
    }

    std::string filename( m_GL_TAPsResourcePath + std::string("GLSL/Shaders/") + shaderFileName );

    // Create and compile shaders from files
    if ( useVertexShader ) {
        std::string vertFile = filename + std::string(".vert");
        if ( !glslManager.AttachShaderFromFile( glslProgObj, vertFile, GL_VERTEX_SHADER ) ) {
            std::cout << "Error ("<<__FILE__<<";"<<__LINE__<<"): GLSL couldn't create a vertex shader from file ("<<vertFile<<")!" << std::endl;
            return false;
        }
    }
    if ( useGeometryShader ) {
        std::string geomFile = filename + std::string(".geom");
        if ( !glslManager.AttachShaderFromFile( glslProgObj, geomFile, GL_GEOMETRY_SHADER_EXT ) ) {
            std::cout << "Error ("<<__FILE__<<";"<<__LINE__<<"): GLSL couldn't create a geometry shader from file ("<<geomFile<<")!" << std::endl;
            return false;
        }
    }
    if ( useFragmentShader ) {
        std::string fragFile = filename + std::string(".frag");
        if ( !glslManager.AttachShaderFromFile( glslProgObj, fragFile, GL_FRAGMENT_SHADER ) ) {
            std::cout << "Error ("<<__FILE__<<";"<<__LINE__<<"): GLSL couldn't create a fragment shader from file ("<<fragFile<<")!" << std::endl;
            return false;
        }
    }

    // Link the glsl program object
    if ( !glslManager.Link( glslProgObj ) ) {
        std::cout << "Error ("<<__FILE__<<";"<<__LINE__<<"): GLSL couldn't create link shaders ("<<shaderFileName<<")!" << std::endl;
        return false;
    }

    return true;
}


// Clear shaders
void OpenGLObj::ClearShaders ()
{
}
//-----------------------------------------------------------------------------
#endif//TAPs_USE_GLSL
//=============================================================================



//=============================================================================
#ifdef  TAPs_USE_WXWIDGETS
//-----------------------------------------------------------------------------
// Initialize an 1D texture
//bool OpenGLObj::InitTexture1D ( std::string imageFile )
//{
//  return false;
//}

// Initialize a 2D texture
bool OpenGLObj::InitTexture2D ( std::string & imageFile )
{
    wxImage imgObj( imageFile );
    if ( !imgObj.IsOk() ) {
        std::cout << "Image from \""<<imageFile<<"\" cannont be initialized!\n";
        return false;
    }

    // Get texels from the image object
    int width   = imgObj.GetWidth();
    int height  = imgObj.GetHeight();
    std::cout << "\""<<imageFile<<"\" size: [w:" << width << ", h:" << height << "]" << "\n";
    int numOfComponents = imgObj.HasAlpha() ? 4 : 3;
    GLubyte * texels = new GLubyte[width * height * numOfComponents];
    unsigned char * imgData = imgObj.GetData();
    unsigned char * imgAlpha = imgObj.GetAlpha();
    long count = 0;
    int alphaIdx = 0;
    for ( int n = 0; n < width*height*3; n+=3 ) {
        texels[count++] = /*255 -*/ imgData[n+0];
        texels[count++] = /*255 -*/ imgData[n+1];
        texels[count++] = /*255 -*/ imgData[n+2];
        if ( imgAlpha ) {
            texels[count++] = /*255 -*/ imgAlpha[alphaIdx++];
        }
    }

    // Create texture
    GLint texIntFormat = GL_RGB;
    GLenum pixelFormat = GL_RGB;
    if ( numOfComponents == 4 ) {
        texIntFormat = GL_RGBA;
        pixelFormat = GL_RGBA;
    }
    Texture.ChangeTexture( GL_TEXTURE_2D, 0, texIntFormat, width, height, 0, pixelFormat, GL_UNSIGNED_BYTE, texels );

    delete [] texels;

    return true;
}

// Initialize a 3D texture
//bool OpenGLObj::InitTexture3D ( std::string imageFile )
//{
//  return false;
//}

// Clear textures
void OpenGLObj::ClearTextures ()
{}
//-----------------------------------------------------------------------------
#endif//TAPs_USE_WXWIDGETS
//=============================================================================

//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----