//********************************************
// Texture.cpp
//********************************************
// class CTexture
//********************************************
// pierre.alliez@cnet.francetelecom.fr
// Created : 17/12/97
// Modified : 19/12/97
//********************************************

#include "stdafx.h"
#include "math.h"
#include "Texture.h"
#include "gl/gl.h"
#include "gl/glu.h"
#include "LTGA.h"
// Zyu add on 100722，支持64位
#include "ximage.h"
//#include "planydec.h"
//#include "plexcept.h"
//#include "planybmp.h"
//#include "pldibsect.h"
//#include "plbmpenc.h"


//////////////////////////////////////////////
// CONSTRUCTORS
//////////////////////////////////////////////

//********************************************
// Constructor
//********************************************
CTexture::CTexture()
{
	m_pData = NULL;
	m_Width = 0;
	m_WidthByte32 = 0;
	m_Height = 0;
	m_Depth = 0;
	m_FileName = _T("");
}

//********************************************
// Destructor
//********************************************
CTexture::~CTexture()
{
	Free();
}


//////////////////////////////////////////////
// DATAS
//////////////////////////////////////////////

//********************************************
// Alloc
//********************************************
int CTexture::Alloc(unsigned int width,
										unsigned int height,
										unsigned int depth)
{
	Free();

	unsigned int BytePerPixel = (unsigned int)(depth / 8);
	unsigned int Width32 = WidthByte32(width,depth);

	// Only rgb and rgba modes
	ASSERT(BytePerPixel == 3 || 
		     BytePerPixel == 4);

	m_pData = new unsigned char [Width32 * height];
	if (m_pData == NULL)
		{
		TRACE(_T("CTexture::Alloc : Insuffisant memory\n"));
		AfxMessageBox(_T("CTexture::Alloc : Insufisant memory"));
		return 0;
		}

	// Set members variables
	m_Width = width;
	m_WidthByte32 = Width32;
	m_Height = height;
	m_Depth = depth;
	UpdateHeader();

	return 1;
}

//********************************************
// Free
//********************************************
void CTexture::Free()
{
	if (m_pData != NULL)
		{
		delete [] m_pData;
		m_pData = NULL;
		}
	m_Width = 0;
	m_Height = 0;
	m_Depth = 0;
}


//////////////////////////////////////////////
//////////////////////////////////////////////
// FILE READING
//////////////////////////////////////////////
//////////////////////////////////////////////

//********************************************
// ReadFile
// Redirection
//********************************************
int CTexture::ReadFile(const TCHAR *filename,
											 unsigned int width,
											 unsigned int height,
											 unsigned int depth)
{
	// Cleanup
	Free();

	// Storage
	m_FileName = filename;

	// Extension
	CString string = filename;
	string.MakeLower();
	TRACE(_T("CTexture::ReadFile : file : %s\n"),filename);
	XPathParser parser(string);
	CString extension=(const TCHAR *)parser.m_sExt;
	//CString extension = string.Right(4);

	// Redirection BMP
	int nRet=FALSE;
	if (extension == _T(".bmp")) {
		nRet = ReadFileBMP(filename);
	} else if (extension == _T(".jpg")) {
		nRet = ReadFileJPG(filename);
	} else if (extension == _T(".gif")) {
		nRet =ReadFileGIF(filename);
	} else if (extension == _T(".raw")) {
		nRet = ReadFileRAW(filename,width,height,depth);
	} else {
		// Zyu modify on 100723，支持64位
/*
		  PLAnyPicDecoder Decoder;
		  //Decoder.SetTraceConfig (2, NULL);  //_T("c:\paintlib.log"));
		  PLWinBmp NewBmp;

		  try  {
			Decoder.MakeBmpFromFile (_AS(filename), &NewBmp);
			int iBytePixel=NewBmp.GetBitsPerPixel()/8;
			if (iBytePixel==3 || iBytePixel==4) {
				Free();
				m_Width = NewBmp.GetWidth();
				m_Height = NewBmp.GetHeight();
				m_Depth=NewBmp.GetBitsPerPixel();
				int nWidth32=WidthByte32(m_Width, m_Depth);
				ASSERT(nWidth32==NewBmp.GetBytesPerLine());
				m_pData = new unsigned char[nWidth32*m_Height];
				//unsigned char **pLineArray=NewBmp.GetLineArray();
				//unsigned char *pLine=m_pData;
				
				//for(int i=m_Height-1; i>=0; i--,pLine+=nWidth32) {
				//	memcpy(pLine, pLineArray[i], nWidth32);
				//}
				memcpy(m_pData, NewBmp.GetBits(), nWidth32*m_Height);
				UpdateHeader();
				nRet = TRUE;
			}
		  }  catch (PLTextException e)  {
			char sz[1024];
			sprintf (sz, "Error decoding %s: %s", filename, (const char *)e);
			PLPicDecoder::Trace (1, sz);
		  }  catch (CMemoryException e)  {
			TRACE (_T("Error decoding %s: Out of memory.\n"), filename);
		  }
*/
		Free();
		nRet = (int)CTangentImage::ReadOtherPicFile(filename, m_Header, (char *&)m_pData);

		if (!nRet && extension == _T(".tga"))
			nRet = ReadFileTGA(filename);
	}

	// Storage again
	m_FileName = filename;

	// Unrecognized file format
	//CString message;
	//message.Format(_T("CTexture::ReadFile : invalid file redirection : %s\n"),filename);
	//AfxMessageBox(string);

	return nRet;
}


//********************************************
// ReadFileBMP (*.bmp)
//********************************************
// Read windows bmp files
// Accept only 24 bits
// Size : 2^n x 2^m
//********************************************
int CTexture::ReadFileBMP(const TCHAR *filename)
{

	// Check for valid bmp file
	CFile file;
	CFileException ex;
	
	// Try to open file
	if (!file.Open(filename, CFile::modeRead | CFile::typeBinary,&ex))
	{
		#ifdef _DEBUG
		  afxDump << _T("File could not be opened ") << ex.m_cause << _T("\n");
		#endif
		AfxMessageBox(_T("Unable to open file for reading"));
		return 0;
	}

	// File header
	BITMAPFILEHEADER FileHeader;
	TRY
	{
		file.Read(&FileHeader,sizeof(BITMAPFILEHEADER));
	}
	CATCH(CFileException, e)
	{
		#ifdef _DEBUG
				afxDump << _T("Error during reading ") << e->m_cause << _T("\n");
		#endif
		AfxMessageBox(_T("Error during reading file header"));
		file.Close();
		return 0;
	}
	END_CATCH

	TRACE(_T("FileHeader.bfType : %d\n"),FileHeader.bfType);
	TRACE(_T("FileHeader.bfSize : %d\n"),FileHeader.bfSize);
	TRACE(_T("FileHeader.bfReserved1 : %d\n"),FileHeader.bfReserved1);
	TRACE(_T("FileHeader.bfReserved2 : %d\n"),FileHeader.bfReserved2);
	TRACE(_T("FileHeader.bfOffBits : %d\n"),FileHeader.bfOffBits);

	// Is it a Windows BMP file ? (BM)
  WORD sign = ((WORD) ('M' << 8) | 'B');
	if (FileHeader.bfType != sign)
	{
		AfxMessageBox(_T("Invalid BMP file"));
		file.Close();
		return 0;
	}

	// Image header
	TRY
	{
		file.Read(&m_Header,sizeof(BITMAPINFOHEADER));
	}
	CATCH(CFileException, e)
	{
		#ifdef _DEBUG
				afxDump << _T("Error during reading ") << e->m_cause << _T("\n");
		#endif
		AfxMessageBox(_T("Error during reading image header"));
		file.Close();
		return 0;
	}
	END_CATCH

	// DEBUG
	TRACE(_T("\n"));
	TRACE(_T("**** IMAGE HEADER :\n"));
	TRACE(_T("**** biSize : %d\n"),m_Header.biSize);
	TRACE(_T("**** biWidth : %d\n"),m_Header.biWidth);
	TRACE(_T("**** biHeight : %d\n"),m_Header.biHeight);
	TRACE(_T("**** biPlanes : %d\n"),m_Header.biPlanes);
	TRACE(_T("**** biBitCount : %d\n"),m_Header.biBitCount);
	TRACE(_T("**** biCompression : %d\n"),m_Header.biCompression);
	TRACE(_T("**** biSizeImage : %d\n"),m_Header.biSizeImage);
	TRACE(_T("**** biXPelsPerMeter : %d\n"),m_Header.biXPelsPerMeter);
	TRACE(_T("**** biYPelsPerMeter : %d\n"),m_Header.biYPelsPerMeter);
	TRACE(_T("**** biClrUsed : %d\n"),m_Header.biClrUsed);
	TRACE(_T("**** biClrImportant : %d\n"),m_Header.biClrImportant);

	// 24 bits ?
	if (m_Header.biPlanes != 1 ||
		 m_Header.biBitCount != 24)
	{
		AfxMessageBox(_T("Texture file must have 24 bits depth"));
		file.Close();
		return 0;
	}

	// Alloc (does call Free before)
	Free();
	int nSize=m_Header.biSizeImage;
	if (nSize<=0)
		nSize =WidthByte32(m_Header.biWidth, m_Header.biBitCount)*m_Header.biHeight;
	m_pData = new unsigned char[nSize];
	if (m_pData == NULL)
	{
		//AfxMessageBox(_T("Insuffisant memory"));
		file.Close();
		return 0;
	}

	// Update datas
	m_Width = m_Header.biWidth;
	m_Height = m_Header.biHeight;
	m_Depth = m_Header.biBitCount;



	// Image reading
	TRY
	{
		file.Read(m_pData,nSize);
	}
	CATCH(CFileException, e)
	{
		#ifdef _DEBUG
				afxDump << _T("Error during reading ") << e->m_cause << _T("\n");
		#endif
		//AfxMessageBox(_T("Error during reading image"));
		file.Close();
		return 0;
	}
	END_CATCH

	// Close file
  file.Close();

	// Success, also set FileName
	m_FileName = filename;

	UpdateWidthByte32();

	return 1;
}

// Zyu modify on 100722，支持64位 
//extern BOOL ReadJpeg(FILE *input_file, BITMAPINFOHEADER &bmfHeader, char *&pData);
int CTexture::ReadFileJPG(const TCHAR *filename)
{
	// Zyu modify on 100722，支持64位
/*
	FILE *fp=_tfopen(filename, _T("rb"));
	if (!fp)
		return FALSE;

	// File header
	Free();
	if (!ReadJpeg(fp, m_Header, (char * &)m_pData)) {
		fclose(fp);
		return FALSE;
	}
	fclose(fp);
*/
	// File header
	Free();
	if (!CTangentImage::ReadJpeg(filename, m_Header,(char * &)m_pData))
	{
		return FALSE;
	}

	// DEBUG
	TRACE(_T("\n"));
	TRACE(_T("**** IMAGE HEADER :\n"));
	TRACE(_T("**** biSize : %d\n"),m_Header.biSize);
	TRACE(_T("**** biWidth : %d\n"),m_Header.biWidth);
	TRACE(_T("**** biHeight : %d\n"),m_Header.biHeight);
	TRACE(_T("**** biPlanes : %d\n"),m_Header.biPlanes);
	TRACE(_T("**** biBitCount : %d\n"),m_Header.biBitCount);
	TRACE(_T("**** biCompression : %d\n"),m_Header.biCompression);
	TRACE(_T("**** biSizeImage : %d\n"),m_Header.biSizeImage);
	TRACE(_T("**** biXPelsPerMeter : %d\n"),m_Header.biXPelsPerMeter);
	TRACE(_T("**** biYPelsPerMeter : %d\n"),m_Header.biYPelsPerMeter);
	TRACE(_T("**** biClrUsed : %d\n"),m_Header.biClrUsed);
	TRACE(_T("**** biClrImportant : %d\n"),m_Header.biClrImportant);

	// 24 bits ?
	if (m_Header.biPlanes != 1 ||
		 (m_Header.biBitCount != 24 && m_Header.biBitCount != 32 ))
	{
		//AfxMessageBox(_T("Texture file must have 24 bits depth"));
		return 0;
	}


	// Update datas
	m_Width = m_Header.biWidth;
	m_Height = m_Header.biHeight;
	m_Depth = m_Header.biBitCount;

	// Success, also set FileName
	m_FileName = filename;

	UpdateHeader();

	return 1;
}

// Zyu modify on 100722，支持64位
//extern int WriteJpeg(  FILE * input_file, FILE * output_file);
//extern int g_iSrcImgType;
int CTexture::ReadFileGIF(const TCHAR *filename)
{
	// Zyu modify on 100722
/*
	FILE *fpIn=_tfopen(filename, _T("rb"));
	if (!fpIn)
		return FALSE;
	XString sTempFile=GetTempFileName(_T(".jpg"));
	FILE *fpOut=_tfopen(sTempFile, _T("wb"));
	if (!fpOut) {
		fclose(fpIn);
		return FALSE;
	}
	
	XPushMemVar<int> vTemp(g_iSrcImgType, 1);
    int nRet=WriteJpeg(fpIn, fpOut);
	fclose(fpIn);
	fclose(fpOut);
*/
	XString sTempFile=GetTempFileName(_T(".jpg"));
	int nRet = CTangentImage::WriteJpeg(filename, sTempFile, CXIMAGE_FORMAT_GIF);
    if (!nRet)
		return nRet;
	nRet=ReadFileJPG(sTempFile);
	_tremove(sTempFile);
	return nRet;
}

int CTexture::ReadFileTGA(const TCHAR *filename)
{
	LTGA ltga;
	if (!ltga.LoadFromFile(_AS(filename))) {
		// Zyu modify on 100722，支持64位
/*
		FILE *fpIn=_tfopen(filename, _T("rb"));
		if (!fpIn)
			return FALSE;
		XString sTempFile=GetTempFileName(_T(".jpg"));
		FILE *fpOut=_tfopen(sTempFile, _T("wb"));
		if (!fpOut) {
			fclose(fpIn);
			return FALSE;
		}
		
		XPushMemVar<int> vTemp(g_iSrcImgType, 2);
		int nRet=WriteJpeg(fpIn, fpOut);
		fclose(fpIn);
		fclose(fpOut);
*/
		XString sTempFile=GetTempFileName(_T(".jpg"));
		int nRet = CTangentImage::WriteJpeg(filename, sTempFile, CXIMAGE_FORMAT_TGA);
		if (!nRet)
			return nRet;
		nRet=ReadFileJPG(sTempFile);
		_tremove(sTempFile);
		return nRet;
	}
	if (ltga.GetImageType()!=itRGB && ltga.GetImageType()!=itRGBA)
		return FALSE;

	Free();
	m_FileName=filename;
	m_Depth=ltga.GetPixelDepth();
	m_Width = ltga.GetImageWidth();
	m_Height = ltga.GetImageHeight();
	UpdateWidthByte32();
	int iPixelPerByte=m_Depth/8;
	int nWidthNormal=iPixelPerByte*m_Width;
	m_pData = new unsigned char[m_WidthByte32*m_Height];
	unsigned char *pSrc=ltga.GetPixels();
	for(unsigned int row=0; row<m_Height; row++) {
		unsigned char *pSrcRow=pSrc+row*nWidthNormal;
		unsigned char *pDstRow=m_pData+row*m_WidthByte32;
		memcpy(pDstRow, pSrcRow, nWidthNormal);
	}
	BGRtoRGB(); // Swap R and B
	UpdateHeader();
	return TRUE;

}


//********************************************
// UpdateWidthByte32
//********************************************
void CTexture::UpdateWidthByte32()
{
	m_WidthByte32 = WidthByte32(m_Width,m_Depth);
}

//********************************************
// WidthByte32
//********************************************
unsigned int CTexture::WidthByte32(unsigned int width,
																	 unsigned int depth)
{
	int iPixelPerByte=depth/8;
	int nWidth=width*iPixelPerByte;
	nWidth = (nWidth+3)/4*4;
	return nWidth;

	// 32 bits alignment (4 bytes)
	int rest=(width*depth/8)%4;
	if (rest != 0)
		return (width*depth/8 + 4-rest);
	else
		return (width*depth/8);
}

//********************************************
// UpdateHeader
//********************************************
void CTexture::UpdateHeader()
{
	UpdateWidthByte32();

	m_Header.biWidth = m_Width;
	m_Header.biHeight = m_Height;
	m_Header.biSizeImage = m_WidthByte32 * m_Height;

	m_Header.biSize = 40;
	m_Header.biPlanes = 1;
	m_Header.biBitCount = m_Depth;
	//m_Header.biBitCount = m_Depth;
	m_Header.biCompression = 0;
	m_Header.biXPelsPerMeter = 0;
	m_Header.biYPelsPerMeter = 0;
	m_Header.biClrUsed = 0;
	m_Header.biClrImportant = 0;
}


//********************************************
// ReadFileRAW (*.raw)
//********************************************
// Read raw files
// Accept only 24 or 32 bits
// Size : 2^n x 2^m
//********************************************
int CTexture::ReadFileRAW(const TCHAR *filename,
													unsigned int width,
													unsigned int height,
													unsigned int depth)
{

	ASSERT(width>0);
	ASSERT(height>0);
	ASSERT(depth>0);
	ASSERT(depth%8==0);
	ASSERT(depth/8==3 || depth/8==4);

	// Check for valid file
	CFile file;
	CFileException ex;
	
	// Try to open file
	if (!file.Open(filename, CFile::modeRead | CFile::typeBinary,&ex))
	{
		#ifdef _DEBUG
		  afxDump << _T("File could not be opened ") << ex.m_cause << _T("\n");
		#endif
		AfxMessageBox(_T("Unable to open file for reading"));
		return 0;
	}

	// Alloc (does call Free before)
	if (!Alloc(width,height,depth))
	{
		AfxMessageBox(_T("Insuffisant memory"));
		file.Close();
		return 0;
	}

	// Image reading
	TRY
	{
		file.Read(m_pData,m_Width*m_Height*depth/8);
	}
	CATCH(CFileException, e)
	{
		#ifdef _DEBUG
				afxDump << _T("Error during reading ") << e->m_cause << _T("\n");
		#endif
		AfxMessageBox(_T("Error during reading image"));
		file.Close();
		return 0;
	}
	END_CATCH

	// Close file
  file.Close();

	// Success, also set FileName
	m_FileName = filename;

	return 1;
}

//////////////////////////////////////////////
//////////////////////////////////////////////
// FILE SAVING
//////////////////////////////////////////////
//////////////////////////////////////////////

//********************************************
// SaveFile
// Redirection
//********************************************
int CTexture::SaveFile(const TCHAR *filename)
{
	CString string = filename;
	string.MakeLower();
	TRACE(_T("CTexture::SaveFile : file : %s\n"),filename);

	CString extension = string.Right(4);

	// Redirection RAW
	if (extension == _T(".raw"))
		return SaveFileRAW(filename);

	// Redirection BMP
	if (extension == _T(".bmp"))
		return SaveFileBMP(filename);

	// Unrecognized file format
	CString message;
	message.Format(_T("CTexture::SaveFile : invalid file redirection : %s\n"),filename);
	AfxMessageBox(message);

	return 0;
}


//********************************************
// SaveFileRAW
//********************************************
int CTexture::SaveFileRAW(const TCHAR *filename)
{
	// Check for valid image
	if ((m_Width * m_Height * m_Depth) == 0)
		{
		AfxMessageBox(_T("CTexture::SaveFileRAW : invalid image"));
		return 0;
		}

	// Check for valid file
	CFile file;
	CFileException ex;
	
	// Try to open file
	if (!file.Open(filename, CFile::modeWrite | CFile::typeBinary,&ex))
	{
		#ifdef _DEBUG
		  afxDump << _T("File could not be opened ") << ex.m_cause << _T("\n");
		#endif
		AfxMessageBox(_T("Unable to open file for writing"));
		return 0;
	}

	// Image writing
	TRY
	{
		file.Write(m_pData,m_Width*m_Height*m_Depth/8);
	}
	CATCH(CFileException, e)
	{
		#ifdef _DEBUG
				afxDump << _T("Error during writing ") << e->m_cause << _T("\n");
		#endif
		AfxMessageBox(_T("Error during writing image"));
		file.Close();
		return 0;
	}
	END_CATCH

	// Close file
  file.Close();

	return 1;
}


//********************************************
// SaveFileBMP (*.bmp)
//********************************************
// Save windows bmp files
// Accept only 24 bits
//********************************************
int CTexture::SaveFileBMP(const TCHAR *filename)
{
	if (!IsValid())
		return 0;

	if (m_Depth < 24)
		return 0;

	// Check for valid bmp file
	CFile file;
	CFileException ex;
	
	// Try to open file
	if (!file.Open(filename,CFile::modeCreate | CFile::modeWrite | CFile::typeBinary,&ex))
	{
		#ifdef _DEBUG
		  afxDump << _T("File could not be opened ") << ex.m_cause << _T("\n");
		#endif
		AfxMessageBox(_T("Unable to open file for writing"));
		return 0;
	}

	// File header
	BITMAPFILEHEADER FileHeader;
  WORD sign = ((WORD) (_T('M') << 8) | _T('B'));
	FileHeader.bfType = sign;
  FileHeader.bfSize = 14 + 40 + m_WidthByte32*m_Height; 
  FileHeader.bfReserved1 = 0; 
  FileHeader.bfReserved2 = 0; 
  FileHeader.bfOffBits = 54; 

	TRACE(_T("\nSave BMP File...\n"));
	TRACE(_T("FileHeader.bfType : %d\n"),FileHeader.bfType);
	TRACE(_T("FileHeader.bfSize : %d\n"),FileHeader.bfSize);
	TRACE(_T("FileHeader.bfReserved1 : %d\n"),FileHeader.bfReserved1);
	TRACE(_T("FileHeader.bfReserved2 : %d\n"),FileHeader.bfReserved2);
	TRACE(_T("FileHeader.bfOffBits : %d\n"),FileHeader.bfOffBits);

	TRY
	{
		file.Write(&FileHeader,sizeof(BITMAPFILEHEADER));
	}
	CATCH(CFileException, e)
	{
		#ifdef _DEBUG
				afxDump << _T("Error during writing ") << e->m_cause << _T("\n");
		#endif
		AfxMessageBox(_T("Error during writing file header"));
		file.Close();
		return 0;
	}
	END_CATCH

	// Image header
	TRY
	{
		file.Write(&m_Header,sizeof(BITMAPINFOHEADER));
	}
	CATCH(CFileException, e)
	{
		#ifdef _DEBUG
				afxDump << _T("Error during writing ") << e->m_cause << _T("\n");
		#endif
		AfxMessageBox(_T("Error during writing image header"));
		file.Close();
		return 0;
	}
	END_CATCH

	// DEBUG
	TRACE(_T("\n"));
	TRACE(_T("**** IMAGE HEADER :\n"));
	TRACE(_T("**** biSize : %d\n"),m_Header.biSize);
	TRACE(_T("**** biWidth : %d\n"),m_Header.biWidth);
	TRACE(_T("**** biHeight : %d\n"),m_Header.biHeight);
	TRACE(_T("**** biPlanes : %d\n"),m_Header.biPlanes);
	TRACE(_T("**** biBitCount : %d\n"),m_Header.biBitCount);
	TRACE(_T("**** biCompression : %d\n"),m_Header.biCompression);
	TRACE(_T("**** biSizeImage : %d\n"),m_Header.biSizeImage);
	TRACE(_T("**** biXPelsPerMeter : %d\n"),m_Header.biXPelsPerMeter);
	TRACE(_T("**** biYPelsPerMeter : %d\n"),m_Header.biYPelsPerMeter);
	TRACE(_T("**** biClrUsed : %d\n"),m_Header.biClrUsed);
	TRACE(_T("**** biClrImportant : %d\n"),m_Header.biClrImportant);

	// Image writing
	TRY
	{
		file.Write(m_pData,m_Header.biSizeImage);
	}
	CATCH(CFileException, e)
	{
		#ifdef _DEBUG
				afxDump << _T("Error during writing ") << e->m_cause << _T("\n");
		#endif
		AfxMessageBox(_T("Error during writing image"));
		file.Close();
		return 0;
	}
	END_CATCH

	// Close file
  file.Close();

	return 1;
}




//////////////////////////////////////////////
//////////////////////////////////////////////
// CHECKING
//////////////////////////////////////////////
//////////////////////////////////////////////

//********************************************
// IsValid
//********************************************
int CTexture::IsValid()
{
	int success = 0;
	success = (m_Depth == 24) || (m_Depth == 32);
	success &= (m_Width != 0);
	success &= (m_Height != 0);
	success &= (m_pData != NULL);
	if (!success)
		{
		TRACE(_T("\n"));
		TRACE(_T("Invalid texture\n"));
		TRACE(_T("Width  : %d\n"),m_Width);
		TRACE(_T("Height : %d\n"),m_Height);
		TRACE(_T("Depth  : %d\n"),m_Depth);
		TRACE(_T("Data   : %x\n"),m_pData);
		}
	return success;
}


//********************************************
// HigherPowerOfTwo
//********************************************
int CTexture::HigherPowerOfTwo(int value)
{
	ASSERT(value > 0);
	if (value <= 0)
		return value;

	int power = 1;
	int x = 0;

	while(1)
	{
		x = (int)pow(2.0,power);
		if (x >= value)
			return x;
		power++;
	}

	return value;
}

//********************************************
// LowerPowerOfTwo
//********************************************
int CTexture::LowerPowerOfTwo(int value)
{
	ASSERT(value > 0);
	if (value <= 0)
		return value;

	int power = 1;
	int x = 0;

	while(1)
	{
		x = (int)pow(2.0,power);
		if (x >= value)
			return (int)pow(2.0,power-1);
		power++;
	}

	return value;
}

//********************************************
// SameSize
//********************************************
int CTexture::SameSize(CTexture *pTexture)
{
	int success = (m_Width == pTexture->GetWidth());
	success &= (m_Height == pTexture->GetHeight());
	return success;
}


//********************************************
// Flip BGR to RGB
//********************************************
int CTexture::BGRtoRGB(void)
{
	if (!IsValid())
		return 0;

	unsigned char pixel;
	int BytePerPixel = m_Depth/8;
	for(unsigned int j=0;j<m_Height;j++)
		for(unsigned int i=0;i<m_Width;i++)
		{
			pixel = m_pData[m_WidthByte32*j+i*BytePerPixel+2];
			m_pData[m_WidthByte32*j+i*BytePerPixel+2] = m_pData[m_WidthByte32*j+i*BytePerPixel];
			m_pData[m_WidthByte32*j+i*BytePerPixel] = pixel;
		}
	return 1;
}

//////////////////////////////////////////////
//////////////////////////////////////////////
// DUPLICATE
//////////////////////////////////////////////
//////////////////////////////////////////////

//********************************************
// Extract
//********************************************
int CTexture::Extract(int left,
											int top,
											int right,
											int bottom)
{
	ASSERT(IsValid());

	// Saturate
	if (right == -1)
		right = m_Width-1;
	if (bottom == -1)
		bottom = m_Height-1;

	// Check
	if (left >= right || top >= bottom)
		return 0;
	if (left < 0  || left >= (int)m_Width || 
		 right < 0 || right >= (int)m_Width)
		return 0;
	if (top < 0  || top >= (int)m_Height || 
		 bottom < 0 || bottom >= (int)m_Height)
		return 0;

	int NewWidth = right-left+1;
	int NewWidthByte32 = WidthByte32(NewWidth,m_Depth);
	int NewHeight = bottom-top+1;
	int BytePerPixel = m_Depth / 8;
	int i,j,k;

	TRACE(_T("Start extracting...\n"));
	TRACE(_T("New width : %d\n"),NewWidth);
	TRACE(_T("New height : %d\n"),NewHeight);

	ASSERT(NewWidth>=1);
	ASSERT(NewHeight>=1);

	// Alloc
	unsigned char *pData = new unsigned char[NewWidthByte32*NewHeight];
	if (pData == NULL)
		{
		AfxMessageBox(_T("Insuffisant memeory"));
		return 0;
		}

	for(j=0;j<NewHeight;j++)
		for(i=0;i<NewWidth;i++)
			for(k=0;k<BytePerPixel;k++)
				pData[NewWidthByte32*j+i*BytePerPixel+k] = m_pData[m_WidthByte32*(m_Height-1-(j+top))+(i+left)*BytePerPixel+k];

	// Replace datas
	delete [] m_pData;
	m_pData = pData;
	m_Width = NewWidth;
	m_WidthByte32 = NewWidthByte32;
	m_Height = NewHeight;

	UpdateHeader();

	return 1;
}


//********************************************
// DuplicateMirror
//********************************************
int CTexture::DuplicateMirror(int left,
															int top,
															int right,
															int bottom)
{

	if (!Extract(left,top,right,bottom))
		return 0;

	left = 0;
	right = m_Width-1;
	top = 0;
	bottom = m_Height-1;

	int NewWidth = 2*m_Width;
	int NewWidthByte32 = WidthByte32(NewWidth,m_Depth);
	int NewHeight = 2*m_Height;
	int BytePerPixel = m_Depth / 8;
	int i,j,k;

	TRACE(_T("Start duplicate mirror...\n"));
	TRACE(_T("New width : %d\n"),NewWidth);
	TRACE(_T("New widthbyte32 : %d\n"),NewWidthByte32);
	TRACE(_T("New height : %d\n"),NewHeight);

	ASSERT(NewWidth>=1);
	ASSERT(NewHeight>=1);

	// Alloc
	unsigned char *pData = new unsigned char[NewWidthByte32*NewHeight];
	if (pData == NULL)
		{
		AfxMessageBox(_T("Insuffisant memeory"));
		return 0;
		}

	// o o
	// x o
	for(j=0;j<NewHeight/2;j++)
		for(i=0;i<NewWidth/2;i++)
			for(k=0;k<BytePerPixel;k++)
				pData[NewWidthByte32*j+i*BytePerPixel+k] = m_pData[m_WidthByte32*(bottom-(j+top))+(i+left)*BytePerPixel+k];
	// o o
	// o x
	for(j=0;j<NewHeight/2;j++)
		for(i=NewWidth/2;i<NewWidth;i++)
			for(k=0;k<BytePerPixel;k++)
				pData[NewWidthByte32*j+i*BytePerPixel+k] = m_pData[m_WidthByte32*(bottom-(j+top))+(right-(i-NewWidth/2+left))*BytePerPixel+k];
	// x o
	// o o
	for(j=NewHeight/2;j<NewHeight;j++)
		for(i=0;i<NewWidth/2;i++)
			for(k=0;k<BytePerPixel;k++)
				pData[NewWidthByte32*j+i*BytePerPixel+k] = m_pData[m_WidthByte32*(j-NewHeight/2+top)+(i+left)*BytePerPixel+k];
	// o x
	// o o
	for(j=NewHeight/2;j<NewHeight;j++)
		for(i=NewWidth/2;i<NewWidth;i++)
			for(k=0;k<BytePerPixel;k++)
				pData[NewWidthByte32*j+i*BytePerPixel+k] = m_pData[m_WidthByte32*(j-NewHeight/2+top)+(right-(i-NewWidth/2+left))*BytePerPixel+k];

	// Replace datas
	delete [] m_pData;
	m_pData = pData;
	m_Width = NewWidth;
	m_WidthByte32 = NewWidthByte32;
	m_Height = NewHeight;

	UpdateHeader();

	return 1;
}




//********************************************
// DuplicateRepeatWidth
//********************************************
int CTexture::DuplicateRepeatWidth(int left,
																	 int top,
																	 int right,
																	 int bottom)
{
	if (!Extract(left,top,right,bottom))
		return 0;

	left = 0;
	right = m_Width-1;
	top = 0;
	bottom = m_Height-1;

	int NewWidth = 2*m_Width;
	int NewWidthByte32 = WidthByte32(NewWidth,m_Depth);
	int NewHeight = m_Height;
	int BytePerPixel = m_Depth / 8;
	int i,j,k;

	TRACE(_T("Start duplicate mirror...\n"));
	TRACE(_T("New width : %d\n"),NewWidth);
	TRACE(_T("New widthbyte32 : %d\n"),NewWidthByte32);
	TRACE(_T("New height : %d\n"),NewHeight);

	ASSERT(NewWidth>=1);
	ASSERT(NewHeight>=1);

	// Alloc
	unsigned char *pData = new unsigned char[NewWidthByte32*NewHeight];
	if (pData == NULL)
		{
		AfxMessageBox(_T("Insuffisant memeory"));
		return 0;
		}

	// x o
	for(j=0;j<NewHeight;j++)
		for(i=0;i<NewWidth/2;i++)
			for(k=0;k<BytePerPixel;k++)
				pData[NewWidthByte32*j+i*BytePerPixel+k] = m_pData[m_WidthByte32*(bottom-(j+top))+(i+left)*BytePerPixel+k];
	// o x
	for(j=0;j<NewHeight;j++)
		for(i=NewWidth/2;i<NewWidth;i++)
			for(k=0;k<BytePerPixel;k++)
				pData[NewWidthByte32*j+i*BytePerPixel+k] = m_pData[m_WidthByte32*(bottom-(j+top))+(i-NewWidth/2+left)*BytePerPixel+k];

	// Replace datas
	delete [] m_pData;
	m_pData = pData;
	m_Width = NewWidth;
	m_WidthByte32 = NewWidthByte32;
	m_Height = NewHeight;

	UpdateHeader();

	return 1;
}





//////////////////////////////////////////////
//////////////////////////////////////////////
// ALPHA
//////////////////////////////////////////////
//////////////////////////////////////////////

//********************************************
// SetAlphaLayer
//********************************************
int CTexture::SetAlphaLayer(unsigned char alpha) // 0 - 255
{
	// Check
	if (!IsValid())
		return 0;

	if (m_Depth != 32)
		return 0;

	// Fill alpha layer 
	int size = m_Width * m_Height;
	for(int i=0;i<4*size;i+=4)
		m_pData[i+3] = alpha;

	return 1;
}

//********************************************
// AddAlphaLayer
//********************************************
int CTexture::AddAlphaLayer(unsigned char alpha) // 0 - 255
{
	// Check
	if (!IsValid())
		return 0;

	// Has soon alpha
	if (HasAlpha())
		return SetAlphaLayer(alpha);

	// Alloc memory
	unsigned char *pData = new unsigned char[4*m_Width*m_Height];
	if (pData == NULL)
		{
		AfxMessageBox(_T("CTexture::AddAlphaLayer : insuffisant memory"));
		return 0;
		}

	// Fill new data
	int size = m_Width * m_Height;
	int BytePerPixel = m_Depth / 8;
	ASSERT(size > 0);
	for(int i=0;i<size;i++)
	{
		pData[4*i+0] = m_pData[BytePerPixel*i+0];
		pData[4*i+1] = m_pData[BytePerPixel*i+1];
		pData[4*i+2] = m_pData[BytePerPixel*i+2];
		pData[4*i+3] = alpha;
	}

	// Set new depth
	m_Depth = 32;

	// Replace datas
	delete [] m_pData;
	m_pData = pData;

	return 1;
}


//********************************************
// PutAlpha
// From RGB to grey scales, then alpha layer
//********************************************
int CTexture::PutAlpha(CTexture *pTexture) 
{
	// Check
	if (!IsValid())
		return 0;
	if (!pTexture->IsValid())
		return 0;

	if (!SameSize(pTexture))
		return 0;

	if (!AddAlphaLayer(0))
		return 0;

	// Fill new data
	unsigned char *pData = pTexture->GetData();
	int size = m_Width * m_Height;
	int BytePerPixel = pTexture->GetDepth() / 8;
	ASSERT(size > 0);
	for(int i=0;i<size;i++)
		m_pData[4*i+3] = (unsigned char)((int)pData[BytePerPixel*i+0]+
		                                 (int)pData[BytePerPixel*i+1]+
																		 (int)pData[BytePerPixel*i+2])/3;

	return 1;
}

//////////////////////////////////////////////
//////////////////////////////////////////////
// DISPLAY
//////////////////////////////////////////////
//////////////////////////////////////////////

//********************************************
// Draw
//********************************************
int CTexture::Draw(CDC *pDC,
									 int xOffset,
									 int yOffset,
									 int width,
									 int height)
{
	// Checking
	if (!IsValid())
	  return 0;

	// Flags	
	if (width == -1)
		width = m_Width;
	if (height == -1)
		height = m_Height;

	// Painting
	return SetDIBitsToDevice(pDC->m_hDC,
		                       xOffset,
													 yOffset,
													 width,
													 height,
													 0,
													 0,
													 0,
													 m_Height,
													 GetData(),
													 (CONST BITMAPINFO *)&m_Header,
													 DIB_RGB_COLORS);
}

//********************************************
// ReadBuffer
//********************************************
int CTexture::ReadBuffer(unsigned char *buffer, 
												 int width, 
												 int height, 
												 int depth)
{
	if (buffer == NULL)
		return 0;

	if (!Alloc(width,height,depth))
		return 0;

	int BytePerPixel = depth / 8;

	for(int j=0;j<height;j++)
		for(int i=0;i<width;i++)
			for(int k=0;k<BytePerPixel;k++)
				m_pData[m_WidthByte32*j + i*BytePerPixel+k] = buffer[(width*j+i)*BytePerPixel+k];

	return 1;
}

//********************************************
// Grey
//********************************************
int CTexture::Grey(unsigned int x,
									 unsigned int y)
{
	ASSERT(x<m_Width && x>=0);
	ASSERT(y<m_Height && y>=0);
	int BytePerPixel = m_Depth / 8;
	// Grey scale
	if (BytePerPixel == 1)
		return (int)m_pData[m_WidthByte32*y + x]; 
	else // 24 or 32 bits (alpha layer)
		return (int)((int)m_pData[m_WidthByte32*y + x*BytePerPixel+0]+ 
		             (int)m_pData[m_WidthByte32*y + x*BytePerPixel+1]+
								 (int)m_pData[m_WidthByte32*y + x*BytePerPixel+2])/3;
}


unsigned char * CTexture::RepeatData(int uRep, int vRep)
{
	if (!m_pData)
		return NULL;
	unsigned nSize=m_Width*m_Height*m_Depth/8*uRep*vRep;
	unsigned char *pNewData=new unsigned char[nSize];
	if (!pNewData)
		return NULL;
	int iPerByte=m_Depth/8;
	int nRow=m_Height*vRep;
	int nCol=m_Width*uRep;
	for(int v=0; v<vRep; v++) {
		//unsigned char *vStart=m_nWidth*uRep*iPerByte;
		for(int u=0; u<uRep; u++) {
			//unsigned char *uvStart=vStart + u*m_nWidth*iPerByte;
			// 复制一个Data
			// 按行复制
			for(unsigned int i=0; i<m_Height; i++) {
				// 求(u, v)第i行地址
				int iRow=v*m_Height + i;
				int iCol=u*m_Width;
				unsigned char *pDest=&pNewData[(iRow*nCol+iCol)*iPerByte];
				memcpy(pDest, &m_pData[i*m_Width*iPerByte], m_Width*iPerByte);
			}
		}
	}
	return pNewData;
}

// ** EOF **



// Scale to 2^i alignment
BOOL CTexture::OpenGLScale(unsigned char cMaxSizeShift)
{
	if (m_Width<1 || m_Height<1)
		return FALSE;
     //int nMax=10; //1024     
     int nMaxSize= 1<<cMaxSizeShift;
	 int nNewHeight=m_Height, nNewWidth=m_Width;
	 if (nNewHeight>nMaxSize)
		 nNewHeight=nMaxSize;
	 else {
		 for(unsigned char cShift=1; cShift<cMaxSizeShift; cShift++) {
			 int nLow=1<<cShift;
			 int nUp=1<<(cShift+1);
			 if (nNewHeight==nLow || nNewHeight==nUp)
				 break;
			 if (nNewHeight>nLow && nNewHeight<nUp) {
				 if (nNewHeight-nLow < nUp-nNewWidth) 
					 nNewHeight=nLow;
				 else 
					 nNewHeight=nUp;
				 break;
			 }
		 }
	 }
	 if (nNewWidth>nMaxSize)
		 nNewWidth=nMaxSize;
	 else {
		 for(unsigned char cShift=1; cShift<cMaxSizeShift; cShift++) {
			 int nLow=1<<cShift;
			 int nUp=1<<(cShift+1);
			 if (nNewWidth==nLow || nNewWidth==nUp)
				 break;
			 if (nNewWidth>nLow && nNewWidth<nUp) {
				 if (nNewWidth-nLow < nUp-nNewWidth) 
					 nNewWidth=nLow;
				 else 
					 nNewWidth=nUp;
				 break;
			 }
		 }
	 }
	 if (nNewWidth!=m_Width || nNewHeight!=m_Height) {
		 // Scale it
		 unsigned int Width32 = WidthByte32(nNewWidth, GetDepth());
		 unsigned char *pDataOut=new unsigned char [Width32*nNewHeight];
		 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
		 //if (gluScaleImage(GL_BGR_EXT, m_Width, m_Height, GL_UNSIGNED_BYTE, m_pData,
		//	 nNewWidth, nNewHeight, GL_UNSIGNED_BYTE, pDataOut)==0) {
		 if (ScaleImage(nNewWidth, nNewHeight, pDataOut)) {
			 delete []m_pData;
			 m_pData=pDataOut;
			 m_Width=nNewWidth;
			 m_Height=nNewHeight;
			 UpdateHeader();
			 //SaveFileBMP(_T("c:\\temp\\zjq.bmp"));
		 } else {
			 delete [] pDataOut;
			 return FALSE;
		 }
	 }
	 return TRUE;
}


BOOL CTexture::ScaleImage(unsigned int nNewWidth, unsigned int nNewHeight, 
						  unsigned char *pNewData)
{
	int nWidth32=WidthByte32(nNewWidth, m_Depth);
	int iPerByte=m_Depth/8;
	for(unsigned int i=0; i<nNewHeight; i++) {
		double dv=(double)m_Height/(double)nNewHeight*i;
		unsigned v=(unsigned )dv;
		double vDif=dv-v;
		unsigned v1=v+1;
		ASSERT(v<m_Height && v>=0);
		if (v1>=m_Height)
			v1=m_Height-1;
		for(unsigned int j=0; j<nNewWidth; j++) {
			double du=(double)m_Width/(double)nNewWidth*j;
			unsigned u=(unsigned )du;
			unsigned u1=u+1;
			ASSERT(u<m_Width && u>=0);
			if (u1>=m_Width)
				u1=m_Width-1;
			double uDif=du-u;
			// 用 (u, v), (u+1, v), (u+1, v+1), (u, v+1) 4点的坐标来插值
            unsigned char *rgbNew=pNewData+i*nWidth32+j*iPerByte;
            unsigned char *uv=m_pData+v*m_WidthByte32+u*iPerByte;
			unsigned char *u1v=m_pData+v*m_WidthByte32+u1*iPerByte;
			unsigned char *u1v1=m_pData+v1*m_WidthByte32+u1*iPerByte;
			unsigned char *uv1=m_pData+v1*m_WidthByte32+u*iPerByte;

			double duv=sqrt(vDif*vDif+uDif*uDif);
			double du1v=sqrt(vDif*vDif+(1.0-uDif)*(1.0-uDif));
			double du1v1=sqrt((1.0-vDif)*(1.0-vDif)+(1.0-uDif)*(1.0-uDif));
			double duv1=sqrt((1.0-vDif)*(1.0-vDif)+uDif*uDif);
			double suv = duv/(duv+du1v+du1v1+duv1);
			double su1v = du1v/(duv+du1v+du1v1+duv1);
			double su1v1 = du1v1/(duv+du1v+du1v1+duv1);
			double suv1 = duv1/(duv+du1v+du1v1+duv1);
			for(int m=0; m<iPerByte; m++) 
				rgbNew[m]= AS_INT(uv[m]*suv + u1v[m]*su1v + u1v1[m]*su1v1 + uv1[m]*suv1);
			//memcpy(rgbNew, rgbNew, iPerByte);
		}
	}
	return TRUE;

	/*
	int nRow=m_Height*vRep;
	int nCol=m_Width*uRep;
	for(int v=0; v<vRep; v++) {
		//unsigned char *vStart=m_nWidth*uRep*iPerByte;
		for(int u=0; u<uRep; u++) {
			//unsigned char *uvStart=vStart + u*m_nWidth*iPerByte;
			// 复制一个Data
			// 按行复制
			for(int i=0; i<m_Height; i++) {
				// 求(u, v)第i行地址
				int iRow=v*m_Height + i;
				int iCol=u*m_Width;
				unsigned char *pDest=&pNewData[(iRow*nCol+iCol)*iPerByte];
				memcpy(pDest, &m_pData[i*m_Width*iPerByte], m_Width*iPerByte);
			}
		}
	}*/
}


void CTexture::MakeGrey()
{
	//int nWidthByte32=WidthByte32(nNewWidth, m_Depth);
	int BytePerPixel=m_Depth/8;
	for(unsigned int i=0; i<m_Height; i++) {
		for(unsigned int j=0; j<m_Width; j++) {
			unsigned char *pDat=m_pData + m_WidthByte32*i + j*BytePerPixel;
			unsigned int val=(int)((pDat[0]+pDat[1]+pDat[2])/3.0);
			pDat[0]=pDat[1]=pDat[2]=val;
		}
	}
}


unsigned char *CTexture::CloneData()
{
	unsigned char *pNewData=new unsigned char[m_WidthByte32*m_Height];
	memcpy(pNewData, m_pData, m_WidthByte32*m_Height);
	return pNewData;
}