bool TextureManager::LoadTexture(const char *filename, const unsigned int texID, bool generate, GLenum target,
                                 GLenum image_format, GLint internal_format, GLint level, GLint border) {
  // image format
  FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
  // pointer to the image, once loaded
  FIBITMAP *dib(0);
  // pointer to the image data
  BYTE *bits(0);
  // image width and height
  unsigned int width(0), height(0);
  // OpenGL's image ID to map to
  GLuint gl_texID;

  // check the file signature and deduce its format
  fif = FreeImage_GetFileType(filename, 0);
  // if still unknown, try to guess the file format from the file extension
  if (fif == FIF_UNKNOWN)
    fif = FreeImage_GetFIFFromFilename(filename);
  // if still unkown, return failure
  if (fif == FIF_UNKNOWN)
    return false;

  // check that the plugin has reading capabilities and load the file
  if (FreeImage_FIFSupportsReading(fif))
    dib = FreeImage_Load(fif, filename);
  // if the image failed to load, return failure
  if (!dib)
    return false;

  // retrieve the image data
  bits = FreeImage_GetBits(dib);
  // get the image width and height
  width = FreeImage_GetWidth(dib);
  height = FreeImage_GetHeight(dib);
  // if this somehow one of these failed (they shouldn't), return failure
  if ((bits == 0) || (width == 0) || (height == 0))
    return false;

  // if this texture ID is in use, unload the current texture
  if (m_texID.find(texID) != m_texID.end())
    glDeleteTextures(1, &(m_texID[texID]));

  if (generate) {
    // generate an OpenGL texture ID for this texture
    glGenTextures(1, &gl_texID);
    // store the texture ID mapping
    m_texID[texID] = gl_texID;
    // bind to the new texture ID
    glBindTexture(target, gl_texID);
  }

  // store the texture data for OpenGL use
  glTexImage2D(target, level, internal_format, width, height, border, image_format, GL_UNSIGNED_BYTE, bits);

  // Free FreeImage's copy of the data
  FreeImage_Unload(dib);

  // return success
  return true;
}

bool CTexture::loadTexture2D(std::string sTexturePath, bool bGenerateMipMaps)
{
	FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
	FIBITMAP* dib(0);

	fif = FreeImage_GetFileType(sTexturePath.c_str(), 0); // 检查文件签名，推导其格式
	if(fif == FIF_UNKNOWN) fif = FreeImage_GetFIFFromFilename(sTexturePath.c_str()); 	// 从扩展名猜测格式
	if(fif == FIF_UNKNOWN) return false;

	if(FreeImage_FIFSupportsReading(fif)) dib = FreeImage_Load(fif, sTexturePath.c_str());
	if(!dib) return false;

	GLubyte* bDataPointer = FreeImage_GetBits(dib);
	if(bDataPointer == NULL || FreeImage_GetWidth(dib) == 0 || FreeImage_GetHeight(dib) == 0)
		return false;

	GLenum format = FreeImage_GetBPP(dib) == 24 ? GL_BGR : FreeImage_GetBPP(dib) == 8 ? GL_LUMINANCE : 0;
	createFromData(bDataPointer, 
		FreeImage_GetWidth(dib), FreeImage_GetHeight(dib), FreeImage_GetBPP(dib), format, bGenerateMipMaps);
	
	FreeImage_Unload(dib);

	m_sTexturePath = sTexturePath;
	return true;
}

void FreeImageGifData::add24bitBGRDataPage(int width, int height, BYTE* pData)
{
    FIBITMAP* newBitmap = FreeImage_Allocate(width, height, 24, 0x0000FF, 0x00FF00, 0xFF0000);
    BYTE* bitmapData = FreeImage_GetBits(newBitmap);
    memcpy(bitmapData, pData, width * height * 3);
    
    //Set metadata
    FIBITMAP* convBitmap = FreeImage_ColorQuantizeEx(newBitmap, FIQ_WUQUANT, 256);

    FITAG* delayTag = FreeImage_CreateTag();
    
    FreeImage_SetMetadata(FIMD_ANIMATION, convBitmap, NULL, NULL);

    LONG delayVal = 20;
    if (delayTag) {
        FreeImage_SetTagKey(delayTag, "FrameTime");
        FreeImage_SetTagType(delayTag, FIDT_LONG);
        FreeImage_SetTagCount(delayTag, 1);
        FreeImage_SetTagLength(delayTag, 4);
        FreeImage_SetTagValue(delayTag, &delayVal);
        FreeImage_SetMetadata(FIMD_ANIMATION, convBitmap, FreeImage_GetTagKey(delayTag), delayTag);
        FreeImage_DeleteTag(delayTag);
    }

    FreeImage_AppendPage(m_gifHandle, convBitmap);
    
    int pCount = FreeImage_GetPageCount(m_gifHandle);
    FreeImage_Unload(newBitmap);
    FreeImage_Unload(convBitmap);
}

		GLubyte* Texture::loadToBitmap(std::string path, bool flip)
		{
			const char* pathCStr = path.c_str();

			FREE_IMAGE_FORMAT format = FIF_UNKNOWN;
			format = FreeImage_GetFileType(pathCStr);
			if (format == FIF_UNKNOWN)
				format = FreeImage_GetFIFFromFilename(pathCStr);
			if (format == FIF_UNKNOWN) {
				std::cout << "Failed to load image at " << pathCStr << std::endl;
				return nullptr;
			}
			if (!FreeImage_FIFSupportsReading(format))
			{
				std::cout << "Detected image format cannot be read! " << pathCStr << std::endl;
				return nullptr;
			}

			m_bitmap = FreeImage_Load(format, pathCStr);
			if (flip)
				FreeImage_FlipVertical(m_bitmap);

			GLint bitsPerPixel = FreeImage_GetBPP(m_bitmap);
			if (bitsPerPixel == 32)
				m_bitmap32 = m_bitmap;
			else
				m_bitmap32 = FreeImage_ConvertTo32Bits(m_bitmap);

			m_width = FreeImage_GetWidth(m_bitmap32);
			m_height = FreeImage_GetHeight(m_bitmap32);

			return FreeImage_GetBits(m_bitmap32);
		}

GLuint TextureFromFile(const char* filename)
{
    FREE_IMAGE_FORMAT fileFormat = FIF_UNKNOWN;
    FIBITMAP *image(0);
  
    BYTE* bits(0);
    unsigned int width(0), height(0);
     
    fileFormat = FreeImage_GetFileType(filename, 0);
    image = FreeImage_Load(fileFormat, filename);
  
    if(!image)
        return 0;
  
    bits = FreeImage_GetBits(image);
    width = FreeImage_GetWidth(image);
  
    height = FreeImage_GetHeight(image);
  
    GLuint tex;
    glGenTextures(1, &tex);
  
    glBindTexture(GL_TEXTURE_2D, tex);
    gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, width, height, GL_BGR, GL_UNSIGNED_BYTE, bits);
  
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  
    FreeImage_Unload(image);
  
    return tex;
}

bool ZitexConverter::convert(const QString & inFileName, const ConfigDao & configuration)
{
   auto inFileNameStdStr = inFileName.toStdString();

   Zitex::Reader reader;
   Zitex::Reader::Data data;

   reader.readFromFile(inFileNameStdStr, data);

   for (uint32_t it = 0; it < data.header->texImagesNum; ++it)
   {
      Zitex::TexImageHeader * texImageHeader = data.texImages[it].header;

      if (texImageHeader->level == 0)
      {
         auto width = texImageHeader->width;
         auto height = texImageHeader->height;

         FIBITMAP * fiBitmap = FreeImage_Allocate(width, height, 32);

         squish::DecompressImage(FreeImage_GetBits(fiBitmap), width, height, data.texImages[it].data,
                                 data.header->squishFlags);

         // section(".", 0, -2) copyes from begin to 2nd section from end.
         // The first section from end is the extension

         std::string outFileNameStdStr = inFileName.section(".", 0, -2).append(".png").toStdString();

         FreeImage_FlipVertical(fiBitmap);
         FreeImage_Save(FIF_PNG, fiBitmap, outFileNameStdStr.c_str());

         FreeImage_Unload(fiBitmap);
      }
   }
}

FIBITMAP* getBmpFromPixels(ofPixels_<PixelType> &pix){
	PixelType* pixels = pix.getData();
	unsigned int width = pix.getWidth();
	unsigned int height = pix.getHeight();
	unsigned int bpp = pix.getBitsPerPixel();
	
	FREE_IMAGE_TYPE freeImageType = getFreeImageType(pix);
	FIBITMAP* bmp = FreeImage_AllocateT(freeImageType, width, height, bpp);
	unsigned char* bmpBits = FreeImage_GetBits(bmp);
	if(bmpBits != NULL) {
		int srcStride = width * pix.getBytesPerPixel();
		int dstStride = FreeImage_GetPitch(bmp);
		unsigned char* src = (unsigned char*) pixels;
		unsigned char* dst = bmpBits;
		if(srcStride != dstStride){
			for(int i = 0; i < (int)height; i++) {
				memcpy(dst, src, srcStride);
				src += srcStride;
				dst += dstStride;
			}
		}else{
			memcpy(dst,src,dstStride*height);
		}
	} else {
		ofLogError("ofImage") << "getBmpFromPixels(): unable to get FIBITMAP from ofPixels";
	}
	
	// ofPixels are top left, FIBITMAP is bottom left
	FreeImage_FlipVertical(bmp);

	return bmp;
}

int _tmain(int argc, _TCHAR* argv[])
{
	const char* filename = "1.jpg";
	FREE_IMAGE_FORMAT fif = FreeImage_GetFileType(filename, 0);
	FIBITMAP *dib(0);
	//pointer to the image data
	BYTE* bits(0);
	//image width and height
	unsigned int width(0), height(0);

	if(fif == FIF_UNKNOWN) 
		fif = FreeImage_GetFIFFromFilename(filename);

	if(fif == FIF_UNKNOWN)
		return 1;

	if(FreeImage_FIFSupportsReading(fif))
		dib = FreeImage_Load(fif, filename);

	//retrieve the image data
	bits = FreeImage_GetBits(dib);
	//get the image width and height
	width = FreeImage_GetWidth(dib);
	height = FreeImage_GetHeight(dib);
	//if this somehow one of these failed (they shouldn't), return failure
	if((bits == 0) || (width == 0) || (height == 0))
		return 1;
	return 0;
}

	Texture::Texture(const char* file) {
		FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
		FIBITMAP* dib = nullptr;
		fif = FreeImage_GetFileType(file, 0);
		if (fif == FIF_UNKNOWN)
			fif = FreeImage_GetFIFFromFilename(file);
		if (fif != FIF_UNKNOWN) {
			if (FreeImage_FIFSupportsReading(fif))
				dib = FreeImage_Load(fif, file);
			BYTE* pixels = FreeImage_GetBits(dib);
			int width = FreeImage_GetWidth(dib);
			int height = FreeImage_GetHeight(dib);
			int bits = FreeImage_GetBPP(dib);
			int size = width * height * (bits / 8);
			BYTE* result = new BYTE[size];
			memcpy(result, pixels, size);
			FreeImage_Unload(dib);

			glGenTextures(1, &m_ID);
			glBindTexture(GL_TEXTURE_2D, m_ID);
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, result ? result : NULL);
			glBindTexture(GL_TEXTURE_2D, 0);
		}
		else {
			m_ID = -1;
		}
	}

GLuint Engine::useTexture(char* texDir, bool wrap) {
	FIBITMAP* imagePtr =
		FreeImage_ConvertTo32Bits(
			FreeImage_Load(
				FreeImage_GetFileType(texDir, 0), texDir)
			);
	GLuint texture;
	glGenTextures(1, &texture); // i used to be 1
	glBindTexture(GL_TEXTURE_2D, texture);

	glTexImage2D(GL_TEXTURE_2D, 0,
		GL_SRGB_ALPHA,
		FreeImage_GetWidth(imagePtr),
		FreeImage_GetHeight(imagePtr),
		0, GL_BGRA, GL_UNSIGNED_BYTE,
		(void*)FreeImage_GetBits(imagePtr));

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap ? GL_REPEAT : GL_CLAMP);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap ? GL_REPEAT : GL_CLAMP);

	// Clear from RAM
	FreeImage_Unload(imagePtr);
	// Unbind when finished uplloading
	glBindTexture(GL_TEXTURE_2D, 0);
	return texture;
}

/**
Custom gamma correction based on the ITU-R BT.709 standard
@param dib RGBF image to be corrected
@param gammaval Gamma value (2.2 is a good default value)
@return Returns TRUE if successful, returns FALSE otherwise
*/
static BOOL 
REC709GammaCorrection(FIBITMAP *dib, const float gammaval) {
	if(FreeImage_GetImageType(dib) != FIT_RGBF)
		return FALSE;

	float slope = 4.5F;
	float start = 0.018F;
	
	const float fgamma = (float)((0.45 / gammaval) * 2);
	if(gammaval >= 2.1F) {
		start = (float)(0.018 / ((gammaval - 2) * 7.5));
		slope = (float)(4.5 * ((gammaval - 2) * 7.5));
	} else if (gammaval <= 1.9F) {
		start = (float)(0.018 * ((2 - gammaval) * 7.5));
		slope = (float)(4.5 / ((2 - gammaval) * 7.5));
	}

	const unsigned width  = FreeImage_GetWidth(dib);
	const unsigned height = FreeImage_GetHeight(dib);
	const unsigned pitch  = FreeImage_GetPitch(dib);

	BYTE *bits = (BYTE*)FreeImage_GetBits(dib);
	for(unsigned y = 0; y < height; y++) {
		float *pixel = (float*)bits;
		for(unsigned x = 0; x < width; x++) {
			for(int i = 0; i < 3; i++) {
				*pixel = (*pixel <= start) ? *pixel * slope : (1.099F * pow(*pixel, fgamma) - 0.099F);
				pixel++;
			}
		}
		bits += pitch;
	}

	return TRUE;
}

// CPreview message handlers
void CPreview::OnPaint()
{
	CPaintDC dc(this); // device context for painting

	CRect rct;
	GetClientRect(&rct);

	dc.FillSolidRect(&rct, m_clr);   // Fill background first

	if (m_dib != NULL)
	{
		// Draw the thumbnail
		int width = (int)(FreeImage_GetWidth(m_dib)*theApp.thumb_zoom_);
		if (width > rct.Width()) width = rct.Width();
		int height = (int)(FreeImage_GetHeight(m_dib)*theApp.thumb_zoom_);
		if (height > rct.Height()) height = rct.Height();
		int left = (rct.Width() - width)/2;
		if (left < 0) left = 0;
		::StretchDIBits(dc.GetSafeHdc(),
					left, 0, width, height,
					0, 0, FreeImage_GetWidth(m_dib), FreeImage_GetHeight(m_dib),
					FreeImage_GetBits(m_dib), FreeImage_GetInfo(m_dib), DIB_RGB_COLORS, SRCCOPY);
	}
	else
	{
		// Just draw some text to say there is no preview
		dc.SetTextAlign(TA_CENTER);
		dc.TextOut(rct.Width()/2, 20, "No Preview      ", 12);
		dc.TextOut(rct.Width()/2, 40, "Available       ", 12);
	}
}

static void
TestFIA_IOLoadColourArrayData(CuTest* tc)
{
	FIBITMAP *dib1 = NULL, *dib2 = NULL;
	FREE_IMAGE_TYPE type;
	int bpp, err;
    
	const char *file = "C:\\cup.tif";
	dib1 = FIA_LoadFIBFromFile(file);

	CuAssertTrue(tc, dib1 != NULL);

	dib2 = FreeImage_AllocateT (FIT_BITMAP, FreeImage_GetWidth(dib1), FreeImage_GetHeight(dib1), 8, 0, 0, 0);

	PROFILE_START("CopyColourBytesToFIBitmap");

	for(int i=0; i < 1000; i++) {

		//FIA_CopyColourBytesToFIBitmap (dib2, FreeImage_GetBits(dib1), 0, 1, COLOUR_ORDER_RGB);
		FIA_CopyColourBytesTo8BitFIBitmap (dib2, FreeImage_GetBits(dib1), 24, FI_RGBA_RED, 0, 1);

	}

	PROFILE_STOP("CopyColourBytesToFIBitmap");

	FIA_SaveFIBToFile (dib2, TEST_DATA_OUTPUT_DIR "/IO/save-colour-test.bmp", BIT8);

	FreeImage_Unload(dib1);
	FreeImage_Unload(dib2);
}

GLuint load_texture(char* file, GLint param)
{
	BYTE* bits(0);
	unsigned int width(0), height(0);
	GLuint gl_texID;
	FIBITMAP *dib = get_dib(file);
	if (!dib)
		return -1;
	bits = FreeImage_GetBits(dib);
	width = FreeImage_GetWidth(dib);
	height = FreeImage_GetHeight(dib);
	if ((bits == 0) || (width == 0) || (height == 0))
		return -1;
	glGenTextures(1, &gl_texID);
	glBindTexture(GL_TEXTURE_2D, gl_texID);
	if (FreeImage_GetBPP(dib) == 24){
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_BGR, GL_UNSIGNED_BYTE, bits);
	}
	else if (FreeImage_GetBPP(dib) == 32){
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, bits);
	}
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, param);
	glBindTexture(GL_TEXTURE_2D,0);
	FreeImage_Unload(dib);
	return gl_texID;
}

/*
* \brief Method that import a texture to be used on the model
* \param[in] fTexture a constant char array containing the path to the file of the texture
* \param[in] tex_number an unsigned integer representing the type of texture (i.e. 0 = Diffuse color, 1 = Normalmap, 2 = Specular Color)
* \return a boolean indicating if the import was successful of not
*/
GLboolean Model::importTexture(const GLchar * fTexture, GLuint tex_number)
{
	GLboolean import_is_ok = GL_FALSE;
	FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
	FIBITMAP *dib(0);
	BYTE* bits(0);
	GLuint width(0), height(0);

	fif = FreeImage_GetFileType(fTexture, 0);

	if (FreeImage_FIFSupportsReading(fif))
	{
		dib = FreeImage_Load(fif, fTexture);
		dib = FreeImage_ConvertTo32Bits(dib);
		bits = FreeImage_GetBits(dib);
		width = FreeImage_GetWidth(dib);
		height = FreeImage_GetHeight(dib);
		import_is_ok = GL_TRUE;

		glBindTexture(GL_TEXTURE_2D, m_texture_id[tex_number]);
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, &bits[0]);
		glGenerateMipmap(GL_TEXTURE_2D);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);

		FreeImage_Unload(dib);
	}
	return import_is_ok;
}

	///////////////////////////////////////////////////////////////////////////
	///
	/// @fn bool glLoadTexture(const std::string& nomFichier, unsigned int& idTexture,
	///                        bool genererTexture)
	///
	/// Cette fonction crée une texture OpenGL à partir d'une image contenu
	/// dans un fichier.  FreeImage est utilisée pour lire l'image, donc tous
	/// les formats reconnues par cette librairie devraient être supportés.
	///
	/// @param[in]  nomFichier     : Le nom du fichier image à charger.
	/// @param[out] idTexture      : L'identificateur de la texture créée.
	/// @param[in]  genererTexture : Doit-on demander à OpenGL de générer un numéro
	///										de texture au préalable?
	///
	/// @return Vrai si le chargement a réussi, faux autrement.
	///
	///////////////////////////////////////////////////////////////////////////
	bool glLoadTexture(const std::string& nomFichier, unsigned int& idTexture, bool genererTexture)
	{
		// Ce code de lecture générique d'un fichier provient de la
		// documentation de FreeImage
		FREE_IMAGE_FORMAT format = FIF_UNKNOWN;
		// check the file signature and deduce its format
		// (the second argument is currently not used by FreeImage)
		format = FreeImage_GetFileType(nomFichier.c_str(), 0);
		if(format == FIF_UNKNOWN) {
			// no signature ?
			// try to guess the file format from the file extension
			format = FreeImage_GetFIFFromFilename(nomFichier.c_str());
		}
		// check that the plugin has reading capabilities ...
		if((format == FIF_UNKNOWN) || !FreeImage_FIFSupportsReading(format)) {
			utilitaire::afficherErreur(
				std::string("Format du fichier image \"") +
				std::string(nomFichier.c_str()) + std::string("\" non supporté")
				);
			return false;
		}
		// ok, let's load the file
		FIBITMAP* dib = FreeImage_Load(format, nomFichier.c_str(), 0);

		if (dib == 0) {
			utilitaire::afficherErreur(
				std::string("Erreur à la lecture du fichier \"") +
				std::string(nomFichier.c_str()) + std::string("\"")
				);
			return false;
		}

		FIBITMAP* dib32 = FreeImage_ConvertTo32Bits(dib);
		if (dib32 == 0) {
			utilitaire::afficherErreur(
				std::string("Incapable de convertir le fichier \"") +
				std::string(nomFichier.c_str()) + std::string("\" en 32 bpp.")
				);
			FreeImage_Unload(dib);
			return false;
		}

		int pitch = FreeImage_GetPitch(dib32);

		glCreateTexture(
			FreeImage_GetBits(dib32),
			FreeImage_GetWidth(dib32),
			FreeImage_GetHeight(dib32),
			FreeImage_GetBPP(dib32),
			FreeImage_GetPitch(dib32),
			idTexture,
			genererTexture
			);

		FreeImage_Unload(dib32);
		FreeImage_Unload(dib);

		return true;
	}

unsigned char * HVSTGFX::loadImageFile(char *fileName, HVSTGFX::IMAGEFILE * imgFile,  GLuint &texture)
{
	//FREE_IMAGE_FORMAT fif = FIF_PNG;

	FREE_IMAGE_FORMAT fif = FreeImage_GetFIFFromFilename(fileName);

	//pointer to the image data
	unsigned char* bits;
	unsigned char tempRGB;
	GLuint tempTex = 0;
	GLenum errCode;
	const unsigned char *errString;
	bool error = false;
	std::string file(fileName);
	
	if(FreeImage_FIFSupportsReading(fif))
		imgFile->dib = FreeImage_Load(fif, fileName);
	

	if(!imgFile->dib)
	{
		glbl->debugger->writeString("failed to open sprite " + *fileName);
		return NULL;
	}

	bits = FreeImage_GetBits(imgFile->dib);
	imgFile->width = FreeImage_GetWidth(imgFile->dib); imgFile->height = FreeImage_GetHeight(imgFile->dib);
	imgFile->size = sizeof(bits);
	int size = imgFile->width*imgFile->height;//(FreeImage_GetWidth(dib) * FreeImage_GetHeight(dib));

	for (int imageIDx = 0; imageIDx < size * 4; imageIDx += 4)
	{
		tempRGB = bits[imageIDx];
		bits[imageIDx] = bits[imageIDx + 2];
		bits[imageIDx + 2] = tempRGB;
	}
	
	glGenTextures(1, &tempTex);
	texture = tempTex;
	
	errCode = glGetError();
	if (errCode != GL_NO_ERROR)
	{
		MessageBox(NULL, _T("Unable to detect OpenGL support. Check if you have your graphics driver installed, or if your graphics card supports OpenGL."), NULL, NULL);
	}
	glBindTexture(GL_TEXTURE_2D, texture);
	
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imgFile->width, imgFile->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, bits);
	
	//FreeImage_Unload(dib);
	
#ifdef _DEBUG
	if (!error)
		glbl->debugger->writeString("successfully loaded sprite " + file + "\n");
#endif
	return bits;
}

	FREEIMAGE_BMP*
	FREEIMAGE_LoadImage(const UString& filePath)
	{
		FREEIMAGE_BMP* vix_bmp = new FREEIMAGE_BMP;
		vix_bmp->path = filePath;
		vix_bmp->name = getFileName(filePath);
		vix_bmp->format = FREEIMAGE_FormatFromExtension(getFileExtension(filePath, false));
		vix_bmp->data = NULL;
		vix_bmp->bitmap = NULL;

		/*Here we must */
		
		//Check file signature and deduce format
#ifdef UNICODE
		vix_bmp->format = FreeImage_GetFileTypeU(filePath.c_str());
#else
		vix_bmp->format = FreeImage_GetFileType(filePath.c_str());
#endif
		if (vix_bmp->format == FIF_UNKNOWN) {
#ifdef UNICODE
			vix_bmp->format = FreeImage_GetFIFFromFilenameU(filePath.c_str());
#else
			vix_bmp->format = FreeImage_GetFIFFromFilename(filePath.c_str());
#endif
		}
			
		//if still unknown, return NULL;
		if (vix_bmp->format == FIF_UNKNOWN)
			return NULL;

		//Check if FreeImage has reading capabilities
		if (FreeImage_FIFSupportsReading(vix_bmp->format)) {
#ifdef UNICODE
			//read image into struct pointer
			vix_bmp->bitmap = FreeImage_LoadU(vix_bmp->format, filePath.c_str());
#else
			vix_bmp->bitmap = FreeImage_Load(vix_bmp->format, filePath.c_str());
#endif
			
		}

		//If image failed to load, return NULL
		if (!vix_bmp->bitmap)
			return NULL;

		FreeImage_FlipVertical(vix_bmp->bitmap);

		//Retrieve image data
		vix_bmp->data = FreeImage_GetBits(vix_bmp->bitmap);
		//Retrieve image width
		vix_bmp->header.width = FreeImage_GetWidth(vix_bmp->bitmap);
		//Retrieve image height
		vix_bmp->header.height = FreeImage_GetHeight(vix_bmp->bitmap);
		if (vix_bmp->data == 0 || vix_bmp->header.width == 0 || vix_bmp->header.height == 0)
			return NULL;

		//return bitmap
		return vix_bmp;
	}

/**
Coarse-to-fine prolongation by bilinear interpolation. nf is the fine-grid dimension. The coarsegrid
solution is input as uc[0..nc-1][0..nc-1], where nc = nf/2 + 1. The fine-grid solution is
returned in uf[0..nf-1][0..nf-1].
*/
static void fmg_prolongate(FIBITMAP *UF, FIBITMAP *UC, int nf) {
	int row_uc, row_uf, col_uc, col_uf;

	const int uf_pitch  = FreeImage_GetPitch(UF) / sizeof(float);
	const int uc_pitch  = FreeImage_GetPitch(UC) / sizeof(float);
	
	float *uf_bits = (float*)FreeImage_GetBits(UF);
	const float *uc_bits = (float*)FreeImage_GetBits(UC);
	
	// do elements that are copies
	{
		const int nc = nf/2 + 1;

		float *uf_scan = uf_bits;
		const float *uc_scan = uc_bits;		
		for (row_uc = 0; row_uc < nc; row_uc++) {
			for (col_uc = 0, col_uf = 0; col_uc < nc; col_uc++, col_uf += 2) {
				// calculate UF(2*row_uc, col_uf) = UC(row_uc, col_uc);
				uf_scan[col_uf] = uc_scan[col_uc];
			}
			uc_scan += uc_pitch;
			uf_scan += 2 * uf_pitch;
		}
	}
	// do odd-numbered columns, interpolating vertically
	{		
		for(row_uf = 1; row_uf < nf-1; row_uf += 2) {
			float *uf_scan = uf_bits + row_uf * uf_pitch;
			for (col_uf = 0; col_uf < nf; col_uf += 2) {
				// calculate UF(row_uf, col_uf) = 0.5 * ( UF(row_uf+1, col_uf) + UF(row_uf-1, col_uf) )
				uf_scan[col_uf] = 0.5F * ( *(uf_scan + uf_pitch + col_uf) + *(uf_scan - uf_pitch + col_uf) );
			}
		}
	}
	// do even-numbered columns, interpolating horizontally
	{
		float *uf_scan = uf_bits;
		for(row_uf = 0; row_uf < nf; row_uf++) {
			for (col_uf = 1; col_uf < nf-1; col_uf += 2) {
				// calculate UF(row_uf, col_uf) = 0.5 * ( UF(row_uf, col_uf+1) + UF(row_uf, col_uf-1) )
				uf_scan[col_uf] = 0.5F * ( uf_scan[col_uf + 1] + uf_scan[col_uf - 1] );
			}
			uf_scan += uf_pitch;
		}
	}
}

bool tpImageIO::readHDR(tpImageColorHDR& I, const char* path)
{

	FREE_IMAGE_FORMAT fifmt = FreeImage_GetFileType(path, 0);
	
	if(fifmt == FIF_UNKNOWN)
	{
		std::cerr << "[Error] tpImageIO : Unknow type !" << std::endl; 
		//TODO: Exceptions ?
		return false;
	}
	
	

	FIBITMAP *dib = FreeImage_Load(fifmt, path,0);
    
	if( dib == NULL )
	{
		std::cerr << "[Error] tpImageIO : Impossible d'ouvrir l'image : " << path << std::endl;
		// TODO: Exceptions ?
		return false;
	}

	if(FreeImage_GetImageType(dib)!=FIT_RGBF)
	{
		std::cerr << "[Error] tpImageIO : Unknow type !" << std::endl; 
		//TODO: Exceptions ?
		return false;
	}

	unsigned width = FreeImage_GetWidth(dib);
	unsigned height = FreeImage_GetHeight(dib);
	unsigned pitch = FreeImage_GetPitch(dib);

	I.resize(height,width);

	FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);
	// test pixel access avoiding scanline calculations
	// to speed-up the image processing
	if(image_type == FIT_RGBF) {
		BYTE *bits = (BYTE*)FreeImage_GetBits(dib);
		for(int y = 0; y < height; y++) {
		FIRGBF *pixel = (FIRGBF*)bits;
		for(int x = 0; x < width; x++) {
		I[y][x].r = pixel[x].red;
		I[y][x].g = pixel[x].green;
		I[y][x].b = pixel[x].blue;
		}
		// next line
		bits += pitch;
		}
	}

	FreeImage_Unload(dib);

	return true;
}