STAPsGLObj.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsGLObj.cpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (09/10/2010)
UPDATE          (12/20/2010)
******************************************************************************/
#include "STAPsGLObj.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        GLObj::m_GL_Version[3]          = {-1,-1,-1};
std::string GLObj::m_GL_TAPsResourcePath    = "";
std::string GLObj::m_GL_TAPsGLSLShadersResourcePath = "";
//=============================================================================
// Constructors
//-----------------------------------------------------------------------------
GLObj::GLObj ()
{
    InitOnce();
}
//-----------------------------------------------------------------------------
//GLObj::GLObj ( GLObj const &orig )
//{
    //Material = orig.Material;
//}
//-----------------------------------------------------------------------------
GLObj::~GLObj ()
{
    //ClearShaders();

    #ifdef  TAPs_USE_WXWIDGETS
        //ClearTextures();
    #endif//TAPs_USE_WXWIDGETS
}
//-----------------------------------------------------------------------------
std::string GLObj::StrInfo () const
{
    std::ostringstream ss;
    ss << "-----<<<<< GLObj >>>>>-----";
    //ss << "\n---<<< Material >>>---\n" << Material;
    //ss << "\n---<<< Texture >>>---\n" << Texture;
    ss << "\n";
    return ss.str();
}
//-----------------------------------------------------------------------------
//=============================================================================
// Assignment Operator
//-----------------------------------------------------------------------------
//GLObj & GLObj::operator= ( GLObj const &orig )
//{ 
//  //Material = orig.Material;
//    return *this;
//}
//-----------------------------------------------------------------------------
//=============================================================================
// Draw
//-----------------------------------------------------------------------------
//void GLObj::Draw () const
//{ 
    //???
//}
//-----------------------------------------------------------------------------
//=============================================================================
// Check OpenGL version
//-----------------------------------------------------------------------------
bool GLObj::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;

    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";
    }
    if (GLEW_VERSION_3_3)   {
        std::cout << "OpenGL Version 3.3 is supported.\n";
        m_GL_Version[0] = 3;  m_GL_Version[1] = 3;  m_GL_Version[2] = 0;
    }
    else {
        std::cout << "OpenGL Version 3.3 is NOT supported.\n";
    }
    if (GLEW_VERSION_4_0)   {
        std::cout << "OpenGL Version 4.0 is supported.\n";
        m_GL_Version[0] = 4;  m_GL_Version[1] = 0;  m_GL_Version[2] = 0;
    }
    else {
        std::cout << "OpenGL Version 4.0 is NOT supported.\n";
    }
    if (GLEW_VERSION_4_1)   {
        std::cout << "OpenGL Version 4.1 is supported.\n";
        m_GL_Version[0] = 4;  m_GL_Version[1] = 1;  m_GL_Version[2] = 0;
    }
    else {
        std::cout << "OpenGL Version 4.1 is NOT supported.\n";
    }

    if ( m_GL_Version[0] > 0 )  return true;
    else                        return false;
}
//=============================================================================
// Set the path to TAPs resource
//-----------------------------------------------------------------------------
void GLObj::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";
}
//-----------------------------------------------------------------------------


// Initialize shaders
bool GLObj::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::stringstream ss;
    ss  << m_GL_TAPsResourcePath << "GLSL/Shaders/" << "v"
        << GetVersionMajorNumber() << "_"
        << GetVersionMinorNumber() << "_"
        << GetVersionMinorMinorNumber() << "/";
    m_GL_TAPsGLSLShadersResourcePath = ss.str();
    std::string filename( m_GL_TAPsGLSLShadersResourcePath + 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 GLObj::ClearShaders ()
//{
//}



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

// Initialize a 2D texture
//bool GLObj::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 GLObj::InitTexture3D ( std::string imageFile )
//{
//  return false;
//}

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

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