TQ Custom RLE Ecoded Images

/*
 "               ..;;;;,                     ;;;,    
 '           ..;;;"` ;;:           ,;;;;;: ,;;;:.,;..          _/
 `     ,;..,;;"`    :;;'            :;;"`,;;;;;;"":;;         _/ 
       ;;;"  `:;;. ;;'           ..;;:  .;;,.;;:',;;"    _/_/_/_/_/
      .;;`   ,;;" .;"          ,;;;;;;" :;`',;",;;"         _/
     ,;;,:.,;;;  ,;:          :" ,;:` , `:.;;;;;'`         _/   
     ;;"'':;;:. .;; .          ,;;;,;:;;,;;;, ,;             _/
    :;;..;;;;;; :;' :.        :;;;"` `:;;;;;,;,.;.          _/
  .;;":;;`  '"";;:  ';;       '""   .;;`.;";:;;;;` ;,  _/_/_/_/_/
 ;;;" `'       "::. ,;;:          .;"`  ::. '   .,;;;     _/ 
 ""             ';;;;;;;"        ""     ';;;;;;;;;;`     _/
 
                        Windsoul++

                by 云风 (Cloud Wu)  1999-2001
				
		http://member.netease.com/~cloudwu 
 		mailto:[Only registered and activated users can see links. Click Here To Register...]
 
		请阅读 readme.txt 中的版权信息
		See readme.txt for copyright information.

		Description:		RLE Sprite 头文件
 		Original Author:	Cloud wind
		Authors:
		Create Time:		2001/6/1
		Modify Time:		2001/11/12

.:*W*:._.:*I*:._.:*N*:._.:*D*:._.:*S*:._.:*O*:._.:*U*:._.:*L*:._.:*/

#ifndef _WINDSOUL_SPRITE_H
#define _WINDSOUL_SPRITE_H

#include "wsaddon.h"

#define _ERR_RLESPRITE 'r'
#define WS_RLESPRTIEFILEERR MAKE_ERR(_ERR_RLESPRITE,'FLE')
#define BLIT_ALTERNATE		0x1
#define BLIT_PALETTE		0x5
#define BLIT_EDGE			0x6
 
typedef WPixel* WPalette;
  
struct WSpriteStruct;  

class WINDSOULADD_API WSprite : public WObject {
public: 
	WSprite() {}
	WSprite(WPalette pal,void *data) { Create(pal,data); }
	WSprite(const WSprite& sprite);
	~WSprite();
  
	void Create(const WPalette pal, void *data);   
	
	int GetW() const;
	int GetH() const;
	BLIT_FUNC DrawFunc(DWORD style) const;	// 获得 Draw 函数指针
	WObjStruct *Duplicate(WObjectHeap *heap) const;
	WSpriteStruct *GetSpriteStruct() const { return reinterpret_cast<WSpriteStruct *>(objdata); }	// 获取数据结构
	void SetUserData(DWORD userdata) const;	// 设置用户数据
	bool IsCover(int x,int y) const;		// 判断是否遮挡
	bool IsCover(WPoint p) const { return IsCover(p.x,p.y); }
	const WSprite& operator()(DWORD userdata) const { SetUserData(userdata); return *this; }
	const WSprite& operator()(WPalette addpal) const { SetUserData((DWORD)addpal); return *this; }
	WSERR Load(const char *filename,int *size=0);	// 读文件

	void *Zoom(int w,int h,int bSpecialPal) const;
};

class WINDSOULADD_API WSpritePak {
	void *m_Data;   
	int m_Direction;
	int m_Width;
	int m_Height;
	int m_Kx;
	int m_Ky;
	WPalette m_Pal;
	mutable WPalette m_AddPal;
	DWORD m_Size;
protected:
	int m_Frame;
	WSprite *m_Spt;
public:
	enum { GreyPal=0, RedPal=1, GreenPal=2, BluePal=3, YellowPal=4, BlackPal=5 };
	WSpritePak() : m_Spt(0),m_AddPal(0),m_Size(0) {}
	virtual ~WSpritePak() { Destroy(); }
	WSERR Destroy();								// 销毁
	bool IsValid() const { return (m_Spt!=0); }		// 判断是否有效
 	const WSprite* operator[](int dir) const { ASSERT(IsValid()); return m_Spt+dir*m_Frame; }
	WSERR Load(const char *filename,int skip=0,int size=0);	// 读文件
	void InitAdditionalPal() const;					// 初始化附加 Pal
	int GetDirection() const { return m_Direction; }// 读方向数
	int GetFrame() const { return m_Frame; }		// 读帧数
	int GetWidth() const { return m_Width; }		// 读宽度
	int GetHeight() const { return m_Height; }		// 读高度
	int GetX() const { return m_Kx; }				// 读X
	int GetY() const { return m_Ky; }				// 读Y
	DWORD GetSize() const { return m_Size; }
	const WPalette LightPal(int level) const;		// 返回亮度 Pal
	const WPalette ColorPal(int color) const;		// 返回彩色 Pal
private:
	virtual void ReadAdditional(void *header) {}		// 读附加信息
};
 
class WINDSOULADD_API WSpriteAni : public WSpritePak {
	int *m_Delay;
	mutable int m_CurrentFrame;
	mutable int m_DelayFrame;
public:
	struct Pair {
		short current;
		short delay;
	};
	WSpriteAni();
	~WSpriteAni();
	void Set(int frame=0);
	void Set(Pair &pair,int frame=0) const;
	int TotalFrame() const;
	const WSprite& NextFrame(bool *change=0) const;
	const WSprite& CurrentFrame() const {
		return m_Spt[m_CurrentFrame];
	}
	const WSprite& NextFrame(Pair &pair,bool *change=0) const;
private:
	void ReadAdditional(void *header);
};

#endif

#include "StdAfx.h"   
#include ".\wsprite.h"   
   
#define ERRORBOXE(c) { MessageBox(NULL,c,"提示[wastest]",MB_OK); return; }   
   
CWSprite::CWSprite(void)   
{   
    m_pData      = NULL;   
    m_pFrameHead = NULL;    
    m_pPal       = NULL;   
}   
   
CWSprite::~CWSprite(void)   
{   
    if(m_pData)   
    {   
        delete m_pData;   
        m_pData      = NULL;   
        m_pFrameHead = NULL;   
        m_pPal       = NULL;   
    }   
}   
   
void CWSprite::SetData(const char *filename)   
{   
    if(filename==NULL)   
        ERRORBOXE("文件名错误！");   
   
    WORD wastitle;          //文件标示 SP   
    WORD szHheard;          //文件头大小   
    long filesize;          //文件大小   
    int datasize;           //数据区大小   
    FILE *pf;   
   
    // 打开文件   
    pf=fopen(filename,"rb");   
    if(!pf)   
        ERRORBOXE("打开文件错误！");   
   
    // 获取文件大小   
    fseek(pf,0,SEEK_END);   
    filesize=ftell(pf);   
   
    // 检测文件是否是was文件   
    fseek(pf,0,SEEK_SET);   
    fread(&wastitle,2,1,pf);   
    if(wastitle!='PS')   
    {   
        fclose(pf);   
        ERRORBOXE("文件不是was动画文件！");   
    }   
   
    // 获取文件头的大小   
    fread(&szHheard,2,1,pf);   
   
    // 设置数据区   
    datasize=(int)(filesize-szHheard-4);   
    if(datasize<0)   
    {   
        fclose(pf);   
        ERRORBOXE("错误的文件！");   
    }   
    m_bIsLoading = 1;   // 开始加载数据   
    if(m_pData!=NULL)   
    {   
        delete m_pData;   
        m_pData      = NULL;   
        m_pFrameHead = NULL;   
        m_pPal       = NULL;   
        m_pLine      = NULL;   
        m_pLineData  = NULL;   
    }   
    if((m_pData = new BYTE[datasize])==0)   
    {   
        fclose(pf);   
        m_bIsLoading = 0;   
        ERRORBOXE("分配内存失败！");   
    }   
   
    // 取动画头信息   
    fread(&washead,sizeof(WASFILEHEADER),1,pf);   
    char buf[1024];   
    sprintf(buf,"动画的方向数：%d\n\r每个方向的帧数：%d\n\r动画的宽度：%d\n\r动画的高度：%d\n\r动画的中心 X：%d\n\r动画的中心 Y：%d\n\r",   
        washead.nDirection,washead.nFrame,washead.nHeigh,washead.nWidth,washead.xCenter,washead.yCenter);   
    MessageBox(NULL,buf,"提示",MB_OK);   
   
    // 取动画文件数据   
    fseek(pf,szHheard+4,SEEK_SET);   
    fread(m_pData,datasize,1,pf);   
    fclose(pf);   
   
    // 设置调色板指针   
    m_pPal = (WPixel*)m_pData;   
    m_pFrame = (unsigned int*)(m_pData+512);   
   
    // 结束加载数据   
    m_bIsLoading=0;   
}   
   
//**************************************************   
// 函数名称：DrawPal   
// 函数参数：   
//      pDstData  － 目标数据区    
//      nDstPitch － 目标数据区的行跨度    
// 作用：将本WAS动画的调色板绘制到目标数据区   
// 作者：foxer   
// 时间：2006-09-02   
//**************************************************   
void CWSprite::DrawPal(BYTE* pDstData,int nDstPitch)   
{   
    int x,y,m;   
    WPixel bufdata[20];   
    if(m_bIsLoading==1||m_pData==NULL)   
        return;   
    for(y=0;y<16;y++)   
        for(x=0;x<16;x++)   
        {   
            for(m=0;m<20;m++)   
                bufdata[m]=m_pPal[y*16+x];   
            bufdata[19]=WPixel(255,255,255);   
            for(m=0;m<19;m++)   
                memcpy(pDstData+(y*20+m)*nDstPitch+x*40,bufdata,40);   
            memset(pDstData+(y*20+19)*nDstPitch+x*40,0xFF,40);   
        }   
}   
   
//**************************************************************   
// 函数名：DrawAlpha   
// 函数参数：   
//      pDst      － 目标数据区   
//      nDstPitch － 目标数据区行跨度   
//      cx        － 目标数据区的宽度   
//      cy        － 目标数据区的高度   
//      x         － 需要画到目标的坐标X   
//      y         － 需要画到目标的坐标Y   
//      nDir      － 需要绘制的方向   
//      nFrm      － 需要绘制的帧   
// 作用：将本WAS动画的某方向的某帧绘制到目标数据区的某个坐标点   
// 作者：foxer   
// 时间：2006-09-02   
//**************************************************************   
void CWSprite::DrawAlpha(BYTE* pDst,int nDstPitch,int cx,int cy,int x,int y,int nDir,int nFrm)   
{   
    if(m_bIsLoading==1||m_pData==NULL)   
        return;   
   
    // 设置绘制参数   
    if(nDir>washead.nDirection||nFrm>washead.nFrame)   
        return;   
    int ntmp;   
    int sx,sy,scx,scy;   
    int dx,dy,dcx,dcy;   
    ntmp = m_pFrame[nDir*washead.nFrame+nFrm];   
    if(ntmp==NULL) return;   
    m_pFrameHead = (DATEHEARD*)(m_pData+ntmp);   
    sx=sy=0;   
    scx=m_pFrameHead->Width;   
    scy=m_pFrameHead->Height;   
    dx=x-m_pFrameHead->FramX;   
    dy=y-m_pFrameHead->FramY;   
    dcx=dx+m_pFrameHead->Width;   
    dcy=dy+m_pFrameHead->Height;   
   
    // 裁剪处理   
    if(x-m_pFrameHead->FramX>cx||y-m_pFrameHead->FramY>cy||x+m_pFrameHead->Width-m_pFrameHead->FramX<0||y+m_pFrameHead->Height-m_pFrameHead->FramY<0)   
        return;   
    if(dx<0)     // 左边出来鸟   
    {   
        sx=-dx;   
        dx=0;   
    }   
    if(dy<0)     // 上边出来鸟   
    {   
        sy=-dy;   
        dy=0;   
    }   
    if(dcx>cx)       // 右边出来鸟   
    {   
        scx-=dcx-cx;   
        dcx=cx;   
    }   
    if(dcy>cy)       // 下边出来鸟   
    {   
        scy-=dcy-cy;   
        dcy=cy;   
    }   
    m_pLine=(unsigned int*)(m_pData+ntmp+16);   
    BYTE t,a;   
    WORD px;   
    WORD *dpx;   
    WORD *dstline;   
    int spta,sptb,dpt;   
       
    // 开始绘制   
    for(int m=sy;m<scy;m++)   
    {   
        m_pLineData=(BYTE*)(m_pData+ntmp+m_pLine[m]);   
        dstline=(WORD*)(pDst+(dy+m-sy)*nDstPitch+dx*2);   
        int n=0;   
        while(*m_pLineData!=0x00&&n<scx)   
        {   
            t=*m_pLineData++;   
            if((t&0xC0)==0) // 若bit6～7＝00   
            {   
                if(t&0x20)  // 若bit5=1   
                {   
                    if(n<sx)   
                    {   
                        n++;   
                        if(n>=scx) goto NEXTLINE;   
                        m_pLineData++;   
                        continue;   
                    }   
                    t=t&0x1f;   
                    px=m_pPal[*m_pLineData++].color;   
                    spta=(px&0xF81F)+((px&0x07E0)<<16);   
                    dpx=dstline;   
                    px=*dpx;   
                    sptb=(px&0xF81F)+((px&0x07E0)<<16);   
                    dpt=(spta*t+sptb*(32-t))/32;   
                    *dpx=(((dpt&0x7E00000)>>16)+(dpt&0xF81F));   
                    n++;   
                    dstline++;   
                    if(n>=scx) goto NEXTLINE;   
                }   
                else   
                {   
                    t=t&0x1f;   
                    if(n<sx)   
                    {   
                        if(n+t<sx)   
                        {   
                            m_pLineData+=2;   
                            n+=t;   
                            continue;   
                        }   
                        else   
                        {   
                            while(n<sx&&t>0)   
                            {   
                                n++;   
                                if(n>=scx)   
                                    goto NEXTLINE;   
                                t--;   
                            }   
                        }   
                    }   
                    a=*m_pLineData++;   
                    px=m_pPal[*m_pLineData++].color;   
                    spta=(px&0xF81F)+((px&0x07E0)<<16);   
                    while(t>0)   
                    {   
                        dpx=dstline;   
                        px=*dpx;   
                        sptb=(px&0xF81F)+((px&0x07E0)<<16);   
                        dpt=(spta*a+sptb*(32-a))/32;   
                        *dpx=((dpt&0x7E00000)>>16)+(dpt&0xF81F);   
                        t--;   
                        n++;   
                        if(n>=scx) goto NEXTLINE;   
                        dstline++;   
                    }   
                }   
            }   
            else if((t&0xC0)==0x40) // 若bit6～7＝01   
            {   
                t=t&0x3f;   
                dpx=dstline;   
                while(t>0)   
                {   
                    if(n<sx)   
                    {   
                        n++;   
                        m_pLineData++;   
                        if(n>=scx) goto NEXTLINE;   
                        t--;   
                        continue;   
                    }   
                    dstline++;   
                    px=m_pPal[*m_pLineData++].color;   
                    *dpx=px;   
                    dpx++;   
                    t--;   
                    n++;   
                    if(n>=scx) goto NEXTLINE;   
                }   
            }   
            else if((t&0xC0)==0x80) // 若bit6～7＝10   
            {   
                t=t&0x3f;   
                if(n+t<sx)   
                {   
                    m_pLineData++;   
                    n+=t;   
                    if(n>=scx) goto NEXTLINE;   
                    continue;   
                }   
                else if(n<sx)   
                {   
                    while(n<sx)   
                    {   
                        n++;   
                        if(n>=scx) goto NEXTLINE;   
                        t--;   
                    }   
                }   
                px=m_pPal[*m_pLineData++].color;   
                   
                while(t>0)   
                {   
                    dpx=dstline;   
                    *dpx=px;   
                    t--;   
                    n++;   
                    if(n>=scx) goto NEXTLINE;   
                    dstline++;   
                }   
            }   
            else        // 若bit6～7＝11   
            {   
                t=t&0x3f;   
                while(n<sx&&t>0)   
                {   
                    n++;   
                    if(n>=scx) goto NEXTLINE;   
                    t--;   
                }   
                n+=t;   
                if(n>=scx) goto NEXTLINE;   
                dstline+=t;   
            }   
        }   
NEXTLINE:;   
    }   
}   
   
int CWSprite::GetDirection()   
{   
    return washead.nDirection;   
}   
   
int CWSprite::GetFrame()   
{   
    return washead.nFrame;   
}

/*
 "               ..;;;;,                     ;;;,    
 '           ..;;;"` ;;:           ,;;;;;: ,;;;:.,;..          _/
 `     ,;..,;;"`    :;;'            :;;"`,;;;;;;"":;;         _/ 
       ;;;"  `:;;. ;;'           ..;;:  .;;,.;;:',;;"    _/_/_/_/_/
      .;;`   ,;;" .;"          ,;;;;;;" :;`',;",;;"         _/
     ,;;,:.,;;;  ,;:          :" ,;:` , `:.;;;;;'`         _/   
     ;;"'':;;:. .;; .          ,;;;,;:;;,;;;, ,;             _/
    :;;..;;;;;; :;' :.        :;;;"` `:;;;;;,;,.;.          _/
  .;;":;;`  '"";;:  ';;       '""   .;;`.;";:;;;;` ;,  _/_/_/_/_/
 ;;;" `'       "::. ,;;:          .;"`  ::. '   .,;;;     _/ 
 ""             ';;;;;;;"        ""     ';;;;;;;;;;`     _/
 
                        Windsoul++

                by ÔÆ·ç (Cloud Wu)  1999-2001
				
		http://member.netease.com/~cloudwu 
		mailto:[Only registered and activated users can see links. Click Here To Register...]
 
		ÇëÔĶÁ readme.txt ÖеİæȨÐÅÏ¢
		See readme.txt for copyright information.

		Description:		RLE Sprite ÄÚ²¿Í·Îļþ
 		Original Author:	ÔÆ·ç
		Authors:
		Create Time:		2001/6/1
		Modify Time:		2001/11/12

.:*W*:._.:*I*:._.:*N*:._.:*D*:._.:*S*:._.:*O*:._.:*U*:._.:*L*:._.:*/

#ifndef _WINDSOUL_SPRITE_INTERNAL_H
#define _WINDSOUL_SPRITE_INTERNAL_H

struct WSpriteStruct : public WObjStruct, memory<WSpriteStruct> {
	int w;									// ¿í¶È
	int h;									// ¸ß¶È
	BYTE **line;							// µÚһɨÃèÐÐÖ¸Õë
	WPalette pal;							// µ÷É«ÅÌ
	DWORD userdata;							// ¶îÍâÊý¾Ý
	void *data;								// Êý¾ÝÖ¸Õë
// 	WSpriteStruct *keyframe;				// Ö¡¼äѹËõÓÃµÄ key Ö¡Ö¸Õë

	WSpriteStruct() {}
	WSpriteStruct(const WSpriteStruct &sprite);
	~WSpriteStruct() {}
	WSpriteStruct& operator=(const WSpriteStruct &sprite);
	using memory<WSpriteStruct>::operator new;
	using memory<WSpriteStruct>::operator delete;
	void *operator new(unsigned size,WObjectHeap *heap) { return WObjStruct::operator new(size,heap); }
#ifndef _BCB
	void operator delete(void *p,WObjectHeap *heap) {};
#endif    
};     
 
struct WSpritePakFileHeader {
//	WORD id;
//	WORD len;	// ´Ó dir ¿ªÊ¼Ò»Ö±µ½ style
	WORD dir;
	WORD frame;
	WORD width;
	WORD height;
	short kx;
	short ky;
//	WPixel pal[256];
//	DWORD offset[1];
};      

struct WSpriteAniFileHeader : public WSpritePakFileHeader {
	BYTE delay[1];
};

#endif

WSERR WSpritePak::Load(const char *filename,int skip,int size)
{
	struct {
		WORD id;
		WORD len;
	} header;

	WFile f;
	int i,s;
	WSpritePakFileHeader *temp;
	DWORD *offset,offset_tbl;
	if (IsValid()) Destroy();
	m_Size=0;
	if (f.Open(filename)) return WS_RLESPRTIEFILEERR;
	f.Skip(skip);
	f.Read(&header,sizeof(header));
//	f.Read(&temp,12);	// ¶Á³ö id, dir, frame, style
	if (header.id!='PS' && header.id!='PA') return WS_RLESPRTIEFILEERR;
	temp=(WSpritePakFileHeader*)_alloca(header.len);
	f.Read(temp,header.len);

	m_Direction=temp->dir;
	m_Frame=temp->frame;
	m_Width=temp->width;
	m_Height=temp->height;
	m_Kx=temp->kx;
	m_Ky=temp->ky;
	ReadAdditional(temp);

	s=m_Direction*m_Frame;
	m_Spt=new WSprite[s];

	offset_tbl=s*sizeof(DWORD);
	offset=(DWORD*)_alloca(offset_tbl);
	
	if (size==0) size=f.GetSize();
//	headersize=sizeof(WSpritePakFileHeader)+(s-1)*sizeof(DWORD);
	m_Size=size-header.len-sizeof(header)-offset_tbl;
	m_Data=WAlloc(m_Size);
	int bytes;
	f.Read(m_Data,512,&bytes);
	if (bytes!=512) goto _error;

	f.Read(offset,offset_tbl,&bytes);
	if (bytes!=(int)offset_tbl) goto _error;

	f.Read((void*)((DWORD)m_Data+512),m_Size-512,&bytes);
	if (bytes!=(int)m_Size-512) goto _error;

	m_Pal=(WPalette)m_Data;

	for (i=0;i<s;i++)  {
		if (offset[i])
			m_Spt[i].Create(m_Pal,(void*)((DWORD)m_Data+offset[i]-offset_tbl));
		else {
			m_Spt[i].Create(0,0);
		}
	}

	return WS_OK;	
_error:
	Destroy();
	return WS_RLESPRTIEFILEERR;
}

#include <windows.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <vector>
#include "FreeImagePlus.h"

using namespace std;

struct tColorRGBA
{
	unsigned char r;
	unsigned char g;
	unsigned char b;
	unsigned char a;
};

struct RLEheader {
	BYTE id[2];
	WORD u1;
	DWORD width;
	DWORD height;
	WORD eight;
	WORD one;
	WORD endOffset;
	WORD zero;
};

bool LoadRLE(string fileName);
tColorRGBA convertBytesToPixel(unsigned char* chunk);
bool write_truecolor_tga(string fileName, vector<tColorRGBA> data, unsigned width, unsigned height);


int main() {
	string fileName = "turtle0";
	LoadRLE(fileName);
	return 1;
}


bool LoadRLE(string fileName) {
	string rleFile = fileName + ".rle";

	RLEheader header;
	unsigned int bytesPerPixel;

	//RLE parts
	unsigned char packetHead;
	unsigned char *chunk;

	tColorRGBA pixel;
	vector<tColorRGBA> pixels;

	ifstream ifs(rleFile, ios::binary | ios::ate);
	ifstream::pos_type pos = ifs.tellg();
	int fileSize = pos;
	
	ifs.seekg(0, ios::beg);
	ifs.read((char*)&header, sizeof(RLEheader));
	int imageOffset = fileSize - header.endOffset;
	int dataSize = fileSize - imageOffset;

	ifs.clear();
	ifs.seekg(imageOffset);
	BYTE *data = new BYTE[dataSize];
	ifs.read((char*)data, dataSize);

	bytesPerPixel = 2;

	int bytesDone = 0;
	//Parse Image Data as packet header followed by 2*count bytes
	while (bytesDone < dataSize) {
		chunk = new unsigned char[2];
		packetHead = data[bytesDone];

		//Run of the same pixel
		if ((packetHead & 0x80)) {
			packetHead &= 0x7F;
			packetHead++;

			chunk[0] = data[bytesDone + 1];
			chunk[1] = data[bytesDone + 2];

			pixel = convertBytesToPixel(chunk);
			for (unsigned char b = 0; b < packetHead; b++) {
				pixels.push_back(pixel);
			}
			bytesDone += bytesPerPixel;
		}
		//Sequence of different pixels
		else {
			packetHead &= 0x7F;
			packetHead++;

			for (unsigned char b = 0; b < packetHead; b++) {
				chunk[0] = data[bytesDone + 1];
				chunk[1] = data[bytesDone + 2];

				pixel = convertBytesToPixel(chunk);
				pixels.push_back(pixel);
				bytesDone += bytesPerPixel;
			}
		}
		bytesDone++;
	}
	ifs.close();
	delete[] data;
	data = NULL;

	write_truecolor_tga(fileName, pixels, header.width, header.height);
	pixels.clear();

	return true;
}


tColorRGBA convertBytesToPixel(unsigned char* chunk) {
	tColorRGBA result;

	result.a = 255 * ((chunk[1] & 0x80) >> 7);
	result.r = (chunk[1] >> 2) & 0x1F;
	result.g = ((chunk[1] << 3) & 0x1C) | ((chunk[0] >> 5) & 0x07);
	result.b = (chunk[0] & 0x1F);

	// Convert 5-bit channels to 8-bit channels by left shifting by three
	// and repeating the first three bits to cover the range [0,255] with
	// even spacing. For example: http://www.ryanjuckett.com/programming/parsing-colors-in-a-tga-file/
	//   channel input bits:        4 3 2 1 0
	//   channel output bits: 4 3 2 1 0 4 3 2
	result.r = (result.r << 3) | (result.r >> 2);
	result.g = (result.g << 3) | (result.g >> 2);
	result.b = (result.b << 3) | (result.b >> 2);

	return result;
}


bool write_truecolor_tga(string fileName, vector<tColorRGBA> data, unsigned width, unsigned height)
{
	int startPos = 0;
	FIBITMAP *bitmap = FreeImage_Allocate(width, height, 32);

	//Most of the images are 'flipped', but not all. method to identify direction not yet found
	int row = height - 1;
	for (unsigned y = 0; y < height; y++) {

		BYTE *bits = FreeImage_GetScanLine(bitmap, row);
		for (unsigned x = 0; x < width; x++) {
			int pixelPos = ((y)* width) + x + startPos;
			tColorRGBA pixel = data.at(pixelPos);

			// Set pixel color
			if (pixel.r == 0 && pixel.g == 0 && pixel.b == 0) bits[3] = 0;
			else bits[3] = 255;
			bits[2] = (char)pixel.r;
			bits[1] = (char)pixel.g;
			bits[0] = (char)pixel.b;

			// jump to next pixel
			bits += 4;
		}
		row--;
	}

	string tgaFile = fileName + ".tga";
	FreeImage_Save(FIF_TARGA, bitmap, tgaFile.c_str(), 0);

	return true;
}