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