TAPsTargaImageHandler.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsTargaImageHandler.hpp

Targa Image Handler
Adapted from OpenGL Superbible (3rd Edition) (2005)

SUKITTI PUNAK   (10/27/2004)
UPDATE          (09/10/2010)
******************************************************************************/
#ifndef TAPs_TARGA_IMAGE_HANDLER_HPP
#define TAPs_TARGA_IMAGE_HANDLER_HPP

#include <iostream>
#include <GL/glext.h>

#ifndef _WINDOWS_
    #include "TAPsWindowsDataTypeDef.hpp"
    using namespace TAPs::WindowsDataTypeDef;
#else
    #include <windows.h>
#endif

#include "../Core/TAPsDef.hpp"

// Uncomment the following #define line for Debug Message
#define TARGAIMAGE_HPP_DEBUG_MODE
#ifdef TARGAIMAGE_HPP_DEBUG_MODE
    #define TARGAIMAGE_HPP_DEBUG_MODE_BY_PRINTF( s ) { printf( "DEBUG MESSAGE: " ); printf s; }
#else
    #define TARGAIMAGE_HPP_DEBUG_MODE_BY_PRINTF( s ) {}
#endif

BEGIN_NAMESPACE_TAPs
//=============================================================================
// Targa File Header
#pragma pack(1)
typedef struct tagTARGAHEADER
{
    unsigned char   identsize;      // Size of ID field that follows header (0)
    unsigned char   colorMapType;   // 0 = None, 1 = paletted
    unsigned char   imageType;      // 0 = none, 1 = indexed, 2 = rgb, 3 = grey, +8=rle
    unsigned short  colorMapStart;  // First colour map entry
    unsigned short  colorMapLength; // Number of colors
    unsigned char   colorMapBits;   // bits per palette entry
    unsigned short  xstart;         // image x origin
    unsigned short  ystart;         // image y origin
    unsigned short  width;          // width in pixels
    unsigned short  height;         // height in pixels
    unsigned char   bits;           // bits per pixel (8 16, 24, 32)
    unsigned char   descriptor;     // image descriptor

} TARGAHEADER;
#pragma pack(8)
//=============================================================================
// CLASS:   Targa Image
// DESC:  Handle a .TGA image file.
class TargaImage {
//******************************************************************************
// Member Functions
public:
    //-------------------------------------------------------------------------
    // Constructor
    TargaImage()
        : m_pucImage( NULL ), m_uiWidth( 0 ), m_uiHeight( 0 ),
        m_uiComponents( GL_BGR_EXT ), m_uiFormat( GL_RGB8 )
    {} // END:  Constructor
    //-------------------------------------------------------------------------
    // Destructor
    ~TargaImage()
    {
        // reclaim the allocated memory if any
        if ( m_pucImage != NULL ) {
            delete [] m_pucImage;
            m_pucImage = NULL;
        }
    } // END:   Destructor
    //-------------------------------------------------------------------------
    // MEMBER FUNCION:  LoadFile()
    // DESC:
    bool LoadFile( char *pcFileName )
    {
        FILE            *filePtr;       // the file pointer
        TARGAHEADER     targaHeader;    // targa header
        unsigned long   lImageSize;     // size in bytes of image
        short           sDepth;         // pixel depth

        // Reclaim the allocated memory if any
        if ( m_pucImage != NULL ) {
            TARGAIMAGE_HPP_DEBUG_MODE_BY_PRINTF( ("Erase an old TGA image data\n") );
            delete [] m_pucImage;
            m_pucImage = NULL;
        }
        else {
            TARGAIMAGE_HPP_DEBUG_MODE_BY_PRINTF( ("the TGA image pointer is new\n") );
        }

        TARGAIMAGE_HPP_DEBUG_MODE_BY_PRINTF( ("Try open the file\n") );
        
        std::cout << "Name: " << pcFileName << std::endl;
        // Try to open filename in "read binary" mode
        if ( ( filePtr = fopen( pcFileName, "rb" ) ) == NULL ) {
            TARGAIMAGE_HPP_DEBUG_MODE_BY_PRINTF( ("Unsucceed opening the TGA image file\n") );
            return false;
        }
        else {
            TARGAIMAGE_HPP_DEBUG_MODE_BY_PRINTF( ("Succeed opening the TGA image file\n") );
        }

        // Read in header (binary)
        fread( &targaHeader, 18/*sizeof( TARGAHEADER )*/, 1, filePtr );

        // Check for supporting only 8, 24, or 32 bit targas
        if (    static_cast<int>(targaHeader.bits) != 8 
            &&  static_cast<int>(targaHeader.bits) != 24 
            &&  static_cast<int>(targaHeader.bits) != 32 ) {
            std::cout << static_cast<int>(targaHeader.bits) << std::endl;
            TARGAIMAGE_HPP_DEBUG_MODE_BY_PRINTF( ("Unsupported format (not 8, 24, or 32 bits)\n") );
            fclose( filePtr );
            return false;
        }
        else {
            TARGAIMAGE_HPP_DEBUG_MODE_BY_PRINTF( ("The format is supported (8, 24, or 32 bits)\n") );
        }

        // Get width, height, and depth of image
        m_uiWidth  = targaHeader.width;
        m_uiHeight = targaHeader.height;
        sDepth     = targaHeader.bits / 8;
        std::cout << "width:  " << m_uiWidth << std::endl;
        std::cout << "height: " << m_uiHeight << std::endl;
        std::cout << "depth:  " << sDepth << std::endl;

        // Calculate the size of image buffer
        lImageSize = targaHeader.width * targaHeader.height * sDepth;

        // Allocate memory and check for success
        m_pucImage = new unsigned char[lImageSize];
        if ( !m_pucImage ) {
            TARGAIMAGE_HPP_DEBUG_MODE_BY_PRINTF( ("Cannot allocate memory for the image\n") );
            fclose( filePtr );
            return false;
        }
        else {
            TARGAIMAGE_HPP_DEBUG_MODE_BY_PRINTF( ("Memory is allocated for the image\n") );
        }

        // Read in the image data
        // Check for read error.
        // Should catch for RLE (compression) or other unsupported formats
        if ( fread( m_pucImage, lImageSize, 1, filePtr ) != 1 ) {
            delete [] m_pucImage;
            m_pucImage = NULL;
            TARGAIMAGE_HPP_DEBUG_MODE_BY_PRINTF( ("Cannot read the image data correctly\n") );
            fclose( filePtr );
            return false;
        }
        else {
            TARGAIMAGE_HPP_DEBUG_MODE_BY_PRINTF( ("Image data is read successfully\n") );
        }

        // Set OpenGL format expected
        switch (sDepth) {
            case 3:     // most likely case
                std::cout << "GL_RGB8" << std::endl;
                m_uiFormat     = GL_BGR_EXT;
                m_uiComponents = GL_RGB8;
                break;
            case 4:     // with alpha channel
                std::cout << "GL_RGBA8" << std::endl;
                m_uiFormat     = GL_BGRA_EXT;
                m_uiComponents = GL_RGBA8;
                break;
            case 1:
                std::cout << "GL_LUMINANCE8" << std::endl;
                m_uiFormat     = GL_LUMINANCE;
                m_uiComponents = GL_LUMINANCE8;
                break;
        };

        // Done with file
        fclose( filePtr );
        return true;
    } // END:   LoadFile()


    //-------------------------------------------------------------------------
    // MEMBER FUNCTION: getImageSize()
    // DESC:
    unsigned int GetWidth() const {
        return m_uiWidth;
        //return m_ucWidth;
    } // END:   getWidth()
    //-------------------------------------------------------------------------
    // MEMBER FUNCTION: getImageSize()
    // DESC:
    unsigned int GetHeight() const {
        //return m_ucHeight;
        return m_uiHeight;
    } // END:   getHeight()
    //-------------------------------------------------------------------------
    // MEMBER FUNCTION: getImageSize()
    // DESC:
    unsigned int GetImageSize() const {
        return  m_uiWidth * m_uiHeight;
    } // END:   getImageSize()
    //-------------------------------------------------------------------------
    // MEMBER FUNCTION: getConstPtrToImageData()
    // DESC:
    unsigned char * const GetConstPtrToImageData() const {
        return m_pucImage;
    } // END:   getConstPtrToImageData()
    //-------------------------------------------------------------------------
    // MEMBER FUNCTION: Available()
    // DESC:
    bool Available() const {
        return m_pucImage != NULL ? true : false;
    } // END:   Available()
    //-------------------------------------------------------------------------

//******************************************************************************
// Data Members
private:
    static const WORD SM_BITMAP_ID;
private:
    unsigned char * m_pucImage;         // a pointer to the image data
    unsigned int    m_uiWidth;          // image width
    unsigned int    m_uiHeight;         // image height
    unsigned int    m_uiComponents;     // component; GL_RGB8, GL_RGBA8, GL_LUMINANCE
    unsigned int    m_uiFormat;         // targa format; 8, 24, or 32 bits
}; // END CLASS TargaImage
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
#endif
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8