TGA.hpp

#ifndef __TGA_HPP
#define __TGA_HPP

        struct  TGA
        {
                unsigned char   commentlen,maptype,filetype;
                unsigned short  maporg,maplen;
                unsigned char   mapsize;
                unsigned short  Xorigin,Yorigin,MaxX,MaxY;
                unsigned char   DataBits,flags;
                
                enum    {       nodata =  0,
                                rawmap =  1,rawrgb =  2, rawmon =  3,
                                rlemap =  9,rlergb = 10, rlemon = 11
                        };
                
                enum
                {
                        invertedflag = 0x20,
                        hasAlphaChannel = 0x08
                };

                void defRGB(unsigned short X,unsigned short Y); 
                
                void defRGBA(unsigned short X,unsigned short Y); 
                
                void def256(unsigned short X,unsigned short Y);

                bool isRGBA() const { return DataBits==32; }
                bool isRGB()  const { return DataBits==24; }
                bool is256()  const { return DataBits==8;  }
                
                unsigned long dataoffset() const
                {
                        if (DataBits==8) return 18 + maplen*3;
                        else             return 18;
                }
                
                bool top_first() const  { return (flags&invertedflag) != 0; }
                
                void   read(const unsigned char hdr[18]);
                
                void   write(unsigned char hdr[18]) const;
        };

inline void TGA::defRGB(unsigned short X,unsigned short Y)
{
        Xorigin=0;      Yorigin=0;
        MaxX=X;         MaxY=Y;

        commentlen=0;
        maptype=nodata;
        filetype=rawrgb;
        maporg=0;       maplen=0;       mapsize=0;
        DataBits=24;
        flags=0;
}

inline void TGA::defRGBA(unsigned short X,unsigned short Y)
{
        defRGB(X,Y);
        DataBits=32;
        flags |= hasAlphaChannel;
}

inline void TGA::def256(unsigned short X,unsigned short Y)
{
        Xorigin=0;      Yorigin=0;
        MaxX=X;         MaxY=Y;

        commentlen=0;
        maptype=rawmap;
        filetype=rawmap;
        maporg=0;
        maplen=256;     // Anzahl der Eintraege ?
        mapsize=24;     // Bit pro Eintrag ?
        DataBits=8;
        flags=0;
}

inline void     TGA::read(const unsigned char hdr[18])
{
        commentlen = hdr[0];
        maptype    = hdr[1];
        filetype   = hdr[2];
        maporg     = int(hdr[3]) + (int(hdr[4])<<8);
        maplen     = int(hdr[5]) + (int(hdr[6])<<8);
        mapsize    = hdr[7];
        Xorigin    = int(hdr[ 8]) + (int(hdr[ 9])<<8);  
        Yorigin    = int(hdr[10]) + (int(hdr[11])<<8);
        MaxX       = int(hdr[12]) + (int(hdr[13])<<8);  
        MaxY       = int(hdr[14]) + (int(hdr[15])<<8);  
        DataBits   = hdr[16];
        flags      = hdr[17];
}
        
inline void     TGA::write(unsigned char hdr[18]) const
{
        hdr[0] = commentlen;
        hdr[1] = maptype;
        hdr[2] = filetype;
        hdr[3] = maporg;        hdr[4] = maporg>>8;
        hdr[5] = maplen;        hdr[6] = maplen>>8;
        hdr[7] = mapsize;
        hdr[8] = Xorigin;       hdr[9]  = Xorigin>>8;
        hdr[10] = Yorigin;      hdr[11] = Yorigin>>8;
        hdr[12] = MaxX;         hdr[13] = MaxX   >>8;
        hdr[14] = MaxY;         hdr[15] = MaxY   >>8;
        hdr[16] = DataBits;
        hdr[17] = flags;                
}


#endif // __TGA_HPP