int TextureLoader::LoadTexture(const char * imagepath)
{
// Load image using the Free Image library
FREE_IMAGE_FORMAT format = FreeImage_GetFileType(imagepath, 0);
FIBITMAP* image = FreeImage_Load(format, imagepath);
FIBITMAP* image32bits = FreeImage_ConvertTo32Bits(image);
// Get an available texture index from OpenGL
GLuint texture = 0;
glGenTextures(1, &texture);
assert(texture != 0);
// Set OpenGL filtering properties (bi-linear interpolation)
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Retrieve width and hight
int width = FreeImage_GetWidth(image32bits);
int height = FreeImage_GetHeight(image32bits);
// This will upload the texture to the GPU memory
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height,
0, GL_BGRA, GL_UNSIGNED_BYTE, (void*)FreeImage_GetBits(image32bits));
// Free images
FreeImage_Unload(image);
FreeImage_Unload(image32bits);
return texture;
}
FIBITMAP *GraphicsHelps::loadImageRC(const char *file)
{
unsigned char *memory = nullptr;
size_t fileSize = 0;
SDL_assert_release(RES_getMem(file, memory, fileSize));
//{
//pLogCritical("Resource file \"%s\" is not found!", file);
//return nullptr;
//}
FIMEMORY *imgMEM = FreeImage_OpenMemory(memory, static_cast<FI_DWORD>(fileSize));
FREE_IMAGE_FORMAT formato = FreeImage_GetFileTypeFromMemory(imgMEM);
if(formato == FIF_UNKNOWN)
return nullptr;
FIBITMAP *img = FreeImage_LoadFromMemory(formato, imgMEM, 0);
FreeImage_CloseMemory(imgMEM);
if(!img)
return nullptr;
FIBITMAP *temp;
temp = FreeImage_ConvertTo32Bits(img);
if(!temp)
return nullptr;
FreeImage_Unload(img);
img = temp;
return img;
}
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;
}
std::shared_ptr<FIBITMAP> load_image(const std::wstring& filename)
{
if(!boost::filesystem::exists(filename))
BOOST_THROW_EXCEPTION(file_not_found() << boost::errinfo_file_name(narrow(filename)));
FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
fif = FreeImage_GetFileTypeU(filename.c_str(), 0);
if(fif == FIF_UNKNOWN)
fif = FreeImage_GetFIFFromFilenameU(filename.c_str());
if(fif == FIF_UNKNOWN || !FreeImage_FIFSupportsReading(fif))
BOOST_THROW_EXCEPTION(invalid_argument() << msg_info("Unsupported image format."));
auto bitmap = std::shared_ptr<FIBITMAP>(FreeImage_LoadU(fif, filename.c_str(), 0), FreeImage_Unload);
if(FreeImage_GetBPP(bitmap.get()) != 32)
{
bitmap = std::shared_ptr<FIBITMAP>(FreeImage_ConvertTo32Bits(bitmap.get()), FreeImage_Unload);
if(!bitmap)
BOOST_THROW_EXCEPTION(invalid_argument() << msg_info("Unsupported image format."));
}
//PNG-images need to be premultiplied with their alpha
if(fif == FIF_PNG)
{
image_view<bgra_pixel> original_view(FreeImage_GetBits(bitmap.get()), FreeImage_GetWidth(bitmap.get()), FreeImage_GetHeight(bitmap.get()));
premultiply(original_view);
}
return bitmap;
}
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);
}
void ImageLoader::
compatible()
{
// BITMAP数据是从下往上的, 需要翻转
FreeImage_FlipVertical(mDIB);
// FreeImage是BGR顺序, 与NVTT要求的一致, 而PVRT需要RGB顺序, 两者都需要32bits数据
if (config.imageCompressionType != CT_DXTC)
{
// 将BGR改为RGB, 交换R channel和B channel
const unsigned bytesperpixel = FreeImage_GetBPP(mDIB) / 8;
const unsigned height = FreeImage_GetHeight(mDIB);
const unsigned pitch = FreeImage_GetPitch(mDIB);
const unsigned lineSize = FreeImage_GetLine(mDIB);
BYTE* line = FreeImage_GetBits(mDIB);
for (unsigned y = 0; y < height; ++y, line += pitch) {
for (BYTE* pixel = line; pixel < line + lineSize; pixel += bytesperpixel) {
INPLACESWAP(pixel[0], pixel[2]);
}
}
}
if (FreeImage_GetBPP(mDIB) != 32)
{
FIBITMAP* convertDIB = FreeImage_ConvertTo32Bits(mDIB);
FreeImage_Unload(mDIB);
mDIB = convertDIB;
}
}
image* createTexture(char* filePath){
//FreeImage_Initialise(FALSE);
FREE_IMAGE_FORMAT formato = FreeImage_GetFileType(filePath,0);//Automatocally detects the format(from over 20 formats!)
FIBITMAP* imagen = FreeImage_Load(formato, filePath,JPEG_ACCURATE);
FIBITMAP* temp = imagen;
imagen = FreeImage_ConvertTo32Bits(imagen);
FreeImage_Unload(temp);
int w = FreeImage_GetWidth(imagen);
int h = FreeImage_GetHeight(imagen);
GLubyte* textura = (GLubyte*) malloc(4*w*h);
char* pixeles = (char*)FreeImage_GetBits(imagen);
//FreeImage loads in BGR format, so you need to swap some bytes(Or use GL_BGR).
int j = 0;
for(; j<w*h; j++){
textura[j*4+0]= pixeles[j*4+2];
textura[j*4+1]= pixeles[j*4+1];
textura[j*4+2]= pixeles[j*4+0];
textura[j*4+3]= pixeles[j*4+3];
}
free(pixeles);
FreeImage_Unload(imagen);
image* imageToReturn = malloc(sizeof(image));
imageToReturn->height = h;
imageToReturn->width = w;
imageToReturn->texture = textura;
return imageToReturn;
}
void loadTexture(char *textureFileName, GLuint &textureMapID)
{
FREE_IMAGE_FORMAT fifmt = FreeImage_GetFileType(textureFileName, 0);
FIBITMAP *dib = FreeImage_Load(fifmt, textureFileName,0);
FIBITMAP *temp = dib;
dib = FreeImage_ConvertTo32Bits(temp);
FreeImage_Unload(temp);
if( dib != NULL )
{
glGenTextures( 1, &textureMapID );
glBindTexture( GL_TEXTURE_2D, textureMapID );
BYTE *pixels = (BYTE*)FreeImage_GetBits(dib);
//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, FreeImage_GetWidth(dib), FreeImage_GetHeight(dib), 0, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
ConfigureAndLoadTexture(pixels, FreeImage_GetWidth(dib), FreeImage_GetHeight(dib) );
glActiveTexture (GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureMapID);
//===================================================================================================
//===================================================================================================
free(pixels);
FreeImage_Unload(dib);
}
}
BOOL fipImage::convertTo32Bits() {
if(_dib) {
FIBITMAP *dib32 = FreeImage_ConvertTo32Bits(_dib);
return replace(dib32);
}
return FALSE;
}
int Init ( AAContext *aaContext )
{
UserData *userData = (UserData*) aaContext->userData;
userData->animation = (Animation*) malloc(sizeof(Animation));
memset(userData->animation, 0x0, sizeof(Animation));
glGenTextures(1, &userData->earth_texture);
glBindTexture(GL_TEXTURE_2D, userData->earth_texture);
FIBITMAP* bitmap = FreeImage_Load(
FreeImage_GetFileType("earth.png", 0),
"earth.png");
FIBITMAP *pImage = FreeImage_ConvertTo32Bits(bitmap);
int nWidth = FreeImage_GetWidth(pImage);
int nHeight = FreeImage_GetHeight(pImage);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, nWidth, nHeight,
0, GL_BGRA, GL_UNSIGNED_BYTE, (void*)FreeImage_GetBits(pImage));
FreeImage_Unload(pImage);
FreeImage_Unload(bitmap); // correct?
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
const char vShaderStr[] =
"uniform mat4 u_mvp; \n"
"attribute vec2 a_texCoords; \n"
"varying vec2 v_texCoords; \n"
"attribute vec4 a_position; \n"
"out float debug; \n"
"void main() \n"
"{ \n"
"vec4 pos = u_mvp * a_position; \n"
"gl_Position = pos; \n"
"v_texCoords = a_texCoords; \n"
"debug = a_position.y; \n"
"} \n";
const char fShaderStr[] =
"in float debug; \n"
"varying vec2 v_texCoords; \n"
"uniform sampler2D s_earthTexture; \n"
"precision mediump float; \n"
"void main() \n"
"{ \n"
"vec4 color = texture(s_earthTexture, v_texCoords); \n"
// "if(debug>0) \n"
// "color = vec4(1.0, 0.0, 0.0, 1.0); \n"
"gl_FragColor = color; \n"
"} \n";
// Load the shaders and get a linked program object
userData->programObject = LoadProgram ( vShaderStr, fShaderStr );
// Get the attribute locations
userData->positionLoc = glGetAttribLocation ( userData->programObject, "a_position" );
userData->mvpLoc = glGetUniformLocation(userData->programObject, "u_mvp");
userData->texCoordsLoc = glGetAttribLocation(userData->programObject, "a_texCoords");
userData->texLoc = glGetUniformLocation(userData->programObject, "s_earthTexture");
glClearColor ( 0.0f, 0.0f, 0.0f, 0.0f );
glEnable(GL_DEPTH_TEST);
return TRUE;
}
RGBAImage* RGBAImage::ReadFromFile(const char* filename)
{
const FREE_IMAGE_FORMAT fileType = FreeImage_GetFileType(filename);
if(FIF_UNKNOWN == fileType)
{
printf("Unknown filetype %s\n", filename);
return 0;
}
FIBITMAP* freeImage = 0;
if(FIBITMAP* temporary = FreeImage_Load(fileType, filename, 0))
{
freeImage = FreeImage_ConvertTo32Bits(temporary);
FreeImage_Unload(temporary);
}
if(!freeImage)
{
printf( "Failed to load the image %s\n", filename);
return 0;
}
RGBAImage *result = ToRGBAImage(freeImage);
FreeImage_Unload(freeImage);
return result;
}
GLuint make_texture(const char *filename) {
GLuint texture;
// Get the image file type from FreeImage.
FREE_IMAGE_FORMAT fifmt = FreeImage_GetFileType(filename, 0);
// Actually load the image file.
FIBITMAP *dib = FreeImage_Load(fifmt, filename, 0);
// Now, there is no guarantee that the image file
// loaded will be GL_RGB, so we force FreeImage to
// convert the image to GL_RGB.
dib = FreeImage_ConvertTo32Bits(dib);
if (dib != NULL) {
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// This is important to note, FreeImage loads textures in
// BGR format. Now we could just use the GL_BGR extension
// But, we will simply swap the B and R components ourselves.
// Firstly, allocate the new bit data doe the image.
//BYTE *bits = malloc(FreeImage_GetWidth(dib) * FreeImage_GetHeight(dib) * 4);
// get a pointer to FreeImage's data.
BYTE *pixels = (BYTE*) FreeImage_GetBits(dib);
// Iterate through the pixels, copying the data
// from 'pixels' to 'bits' except in RGB format.
/*
int pix;
for (pix = 0; pix < FreeImage_GetWidth(dib) * FreeImage_GetHeight(dib); pix++) {
bits[pix * 4 + 0] = pixels[pix * 4 + 2];
bits[pix * 4 + 1] = pixels[pix * 4 + 1];
bits[pix * 4 + 2] = pixels[pix * 4 + 0];
bits[pix * 4 + 3] = pixels[pix * 4 + 3];
}*/
// The new 'glTexImage2D' function, the prime difference
// being that it gets the width, height and pixel information
// from 'bits', which is the RGB pixel data..
//glTexImage2D(GL_TEXTURE_2D, 0, 4, FreeImage_GetWidth(dib), FreeImage_GetHeight(dib), 0,
// GL_RGBA, GL_UNSIGNED_BYTE, bits);
glTexImage2D(GL_TEXTURE_2D, 0, 4, FreeImage_GetWidth(dib), FreeImage_GetHeight(dib), 0,
GL_BGRA, GL_UNSIGNED_BYTE, pixels);
// Unload the image.
// and free the bit data.
FreeImage_Unload(dib);
//free(bits);
} else {
fprintf(stderr, "Can't load texture: %s\n", filename);
}
return texture;
}
bool FreeimagelibPlugin::LoadDoc(cpcl::IOStream *input, plcl::Doc **r) {
FREE_IMAGE_FORMAT fif = (FREE_IMAGE_FORMAT)freeimagelib_format;
FreeimagelibStuff stuff(input);
boost::shared_ptr<FIBITMAP> fibitmap(FreeImage_LoadFromHandle(fif, &stuff.io, stuff.io_handle), FreeImage_Unload);
if (!fibitmap) {
cpcl::Error(cpcl::StringPieceFromLiteral("FreeimagelibPlugin::LoadDoc(): unable to load image"));
return false;
}
if (FreeImage_GetImageType(fibitmap.get()) != FIT_BITMAP) {
boost::shared_ptr<FIBITMAP> tmp(FreeImage_ConvertToType(fibitmap.get(), FIT_BITMAP), FreeImage_Unload);
if (!tmp || (FreeImage_GetImageType(tmp.get()) != FIT_BITMAP)) {
cpcl::Error(cpcl::StringPieceFromLiteral("FreeimagelibPlugin::LoadDoc(): unable to convert the image to FIT_BITMAP"));
return false;
}
fibitmap = tmp;
}
unsigned int const bpp = FreeImage_GetBPP(fibitmap.get());
if (!(bpp == 24 || bpp == 32)) {
boost::shared_ptr<FIBITMAP> tmp((bpp > 32) ? FreeImage_ConvertTo32Bits(fibitmap.get()) : FreeImage_ConvertTo24Bits(fibitmap.get()), FreeImage_Unload);
if (!tmp) {
cpcl::Trace(CPCL_TRACE_LEVEL_ERROR,
"FreeimagelibPlugin::LoadDoc(): unable to convert image with bpp %u",
bpp);
}
fibitmap = tmp;
}
if (r)
*r = new FreeimagelibDoc(fibitmap);
return true;
}
/*
* \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;
}
/**
* Helper to encapsulate Bpp conversion using FreeImage, taking into consideration color type. Creates a new bitmap if needed. Can return the same one.
* @param pHandle FIBITMAP as defined by the Freeimage library.
* @param pNewBpp the new bpp that the supplied FIBITMAP is to be coverted to.
*/
FIBITMAP* FreeImageHelper::convertBpp(FIBITMAP* pHandle, int pNewBpp) {
//Convert the bit depth
FIBITMAP *converted = NULL;
//Convert Bpp only if needed
if (pNewBpp != static_cast<int>(FreeImage_GetBPP(pHandle))) {
//Transform bpp to the pixel format
switch (pNewBpp) {
case (4):
converted = FreeImage_ConvertTo4Bits(pHandle);
break;
case (8):
converted = FreeImage_ConvertTo8Bits(pHandle);
break;
case(16):
converted = FreeImage_ConvertTo16Bits565(pHandle); //There's option of 16Bits555. But leaves unused bits. Chosen 565 because it's most common
break;
case(24):
converted = FreeImage_ConvertTo24Bits(pHandle);
break;
case(32): {
converted = FreeImage_ConvertTo32Bits (pHandle);
}
break;
default:
converted = NULL;
break;
}
} else {
//No change, just set 'converted' handle to current one
converted = pHandle;
}
return converted;
}
void ofImage_<PixelType>::changeTypeOfPixels(ofPixels_<PixelType> &pix, ofImageType newType){
int oldType = pix.getImageType();
if (oldType == newType) {
return; // no need to reallocate
}
FIBITMAP * bmp = getBmpFromPixels(pix);
FIBITMAP * convertedBmp = nullptr;
switch (newType){
case OF_IMAGE_GRAYSCALE:
convertedBmp = FreeImage_ConvertToGreyscale(bmp);
break;
case OF_IMAGE_COLOR:
convertedBmp = FreeImage_ConvertTo24Bits(bmp);
break;
case OF_IMAGE_COLOR_ALPHA:
convertedBmp = FreeImage_ConvertTo32Bits(bmp);
break;
default:
ofLogError("ofImage") << "changeTypeOfPixels(): unknown image type: " << newType;
break;
}
putBmpIntoPixels(convertedBmp, pix, false);
if (bmp != nullptr) {
FreeImage_Unload(bmp);
}
if (convertedBmp != nullptr) {
FreeImage_Unload(convertedBmp);
}
}
void test32BitsChannels(unsigned width, unsigned height) {
BOOL bResult = FALSE;
// create a test 8-bit image
FIBITMAP *src = createZonePlateImage(width, height, 128);
if(src != NULL) {
// convert to 32-bit
FIBITMAP *tmp = FreeImage_ConvertTo32Bits(src);
FreeImage_Unload(src);
src = tmp;
}
assert(src != NULL);
// save for further examination
bResult = FreeImage_Save(FIF_PNG, src, "zoneplate.png", PNG_DEFAULT);
assert(bResult);
// test get/set channel
// -------------------------
FIBITMAP *channel = FreeImage_GetChannel(src, FICC_ALPHA);
assert(channel != NULL);
bResult = FreeImage_SetChannel(src, channel, FICC_ALPHA);
assert(bResult);
FreeImage_Unload(channel);
FreeImage_Unload(src);
}
static void
TestFIA_DrawImageDstRectTest3(CuTest* tc)
{
const char *file = TEST_DATA_DIR "fly.bmp";
FIBITMAP *dib1 = FIA_LoadFIBFromFile(file);
CuAssertTrue(tc, dib1 != NULL);
FIBITMAP *dib2 = FreeImage_ConvertTo32Bits(dib1);
CuAssertTrue(tc, dib2 != NULL);
FIBITMAP *dst = FreeImage_Allocate(790,582, 32, 0, 0, 0);
CuAssertTrue(tc, dst != NULL);
FIA_Matrix *matrix = FIA_MatrixNew();
FIA_MatrixScale(matrix, 2.0, 2.0, FIA_MatrixOrderPrepend);
int err = FIA_DrawImageToDst(dst, dib2, matrix, 0,0,350/2,271/2, FIA_RGBQUAD(128,128,128), 1);
CuAssertTrue(tc, err != FIA_ERROR);
FIA_MatrixDestroy(matrix);
CuAssertTrue(tc, dst != NULL);
FIA_SaveFIBToFile(dst, TEST_DATA_OUTPUT_DIR "Drawing/TestFIA_DrawImageDstRectTest3.bmp", BIT24);
FreeImage_Unload(dib1);
FreeImage_Unload(dib2);
FreeImage_Unload(dst);
}
HBITMAP BmpFilterLoadBitmap(BOOL *bIsTransparent, const wchar_t *ptszFilename)
{
FIBITMAP *dib = (FIBITMAP*)Image_Load(ptszFilename, IMGL_RETURNDIB);
if (dib == nullptr)
return nullptr;
FIBITMAP *dib32 = nullptr;
if (FreeImage_GetBPP(dib) != 32) {
dib32 = FreeImage_ConvertTo32Bits(dib);
FreeImage_Unload(dib);
}
else dib32 = dib;
if (dib32 == nullptr)
return nullptr;
if (FreeImage_IsTransparent(dib32))
if (bIsTransparent)
*bIsTransparent = TRUE;
if (FreeImage_GetWidth(dib32) > 128 || FreeImage_GetHeight(dib32) > 128) {
FIBITMAP *dib_new = FreeImage_MakeThumbnail(dib32, 128, FALSE);
FreeImage_Unload(dib32);
if (dib_new == nullptr)
return nullptr;
dib32 = dib_new;
}
HBITMAP bitmap = FreeImage_CreateHBITMAPFromDIB(dib32);
FreeImage_Unload(dib32);
FreeImage_CorrectBitmap32Alpha(bitmap, FALSE);
return bitmap;
}
std::shared_ptr<RGBAImage> read_from_file(const std::string &filename)
{
const auto file_type = FreeImage_GetFileType(filename.c_str());
if (FIF_UNKNOWN == file_type)
{
throw RGBImageException("Unknown filetype '" + filename + "'");
}
FIBITMAP *free_image = nullptr;
if (auto temporary = FreeImage_Load(file_type, filename.c_str(), 0))
{
free_image = FreeImage_ConvertTo32Bits(temporary);
FreeImage_Unload(temporary);
}
if (not free_image)
{
throw RGBImageException("Failed to load the image " + filename);
}
auto result = to_rgba_image(free_image);
FreeImage_Unload(free_image);
return result;
}
bool readImage(SImage& image, MemChunk& data, int index)
{
// Get image info
SImage::info_t info;
FIBITMAP* bm = getFIInfo(data, info);
// Check it created/read ok
if (!bm)
{
Global::error = "Unable to read image data (unsupported format?)";
return false;
}
// Get image palette if it exists
RGBQUAD* bm_pal = FreeImage_GetPalette(bm);
Palette palette;
if (bm_pal)
{
int a = 0;
int b = FreeImage_GetColorsUsed(bm);
if (b > 256)
b = 256;
for (; a < b; a++)
palette.setColour(a, rgba_t(bm_pal[a].rgbRed, bm_pal[a].rgbGreen, bm_pal[a].rgbBlue, 255));
}
// Create image
if (info.has_palette)
image.create(info, &palette);
else
image.create(info);
uint8_t* img_data = imageData(image);
// Convert to 32bpp & flip vertically
FIBITMAP* rgba = FreeImage_ConvertTo32Bits(bm);
if (!rgba)
{
LOG_MESSAGE(1, "FreeImage_ConvertTo32Bits failed for image data");
Global::error = "Error reading PNG data";
return false;
}
FreeImage_FlipVertical(rgba);
// Load raw RGBA data
uint8_t* bits_rgba = FreeImage_GetBits(rgba);
int c = 0;
for (int a = 0; a < info.width * info.height; a++)
{
img_data[c++] = bits_rgba[a * 4 + 2]; // Red
img_data[c++] = bits_rgba[a * 4 + 1]; // Green
img_data[c++] = bits_rgba[a * 4]; // Blue
img_data[c++] = bits_rgba[a * 4 + 3]; // Alpha
}
// Free memory
FreeImage_Unload(rgba);
FreeImage_Unload(bm);
return true;
}
static void
TestFIA_DrawImageTest3(CuTest* tc)
{
const char *file = TEST_DATA_DIR "fly.bmp";
FIBITMAP *dib1 = FIA_LoadFIBFromFile(file);
CuAssertTrue(tc, dib1 != NULL);
FIBITMAP *dib2 = FreeImage_ConvertTo32Bits(dib1);
CuAssertTrue(tc, dib2 != NULL);
FIBITMAP *dst = FreeImage_Allocate(790,582, 32, 0, 0, 0);
CuAssertTrue(tc, dst != NULL);
int err = FIA_DrawImageFromSrcToDst(dst, dib2, NULL, 0,0,350,271, 350/2,271/2,350/2,271/2,
FIA_RGBQUAD(255,0,255), 0);
CuAssertTrue(tc, err != FIA_ERROR);
CuAssertTrue(tc, dst != NULL);
FIA_SaveFIBToFile(dst, TEST_DATA_OUTPUT_DIR "Drawing/TestFIA_DrawImageTest3.bmp", BIT24);
FreeImage_Unload(dib1);
FreeImage_Unload(dib2);
FreeImage_Unload(dst);
}
static void
TestFIA_AffineTransorm32bitScaleTest(CuTest* tc)
{
const char *file = TEST_DATA_DIR "fly.bmp";
FIBITMAP *dib1 = FIA_LoadFIBFromFile(file);
CuAssertTrue(tc, dib1 != NULL);
FIBITMAP *dib2 = FreeImage_ConvertTo32Bits(dib1);
CuAssertTrue(tc, dib2 != NULL);
FIA_Matrix *matrix = FIA_MatrixNew();
FIA_MatrixScale(matrix, 2.0, 2.0, FIA_MatrixOrderPrepend);
FIBITMAP *transformed_dib = FIA_AffineTransform(dib2, 1000, 1000,
matrix, FIA_RGBQUAD(255,0,255), 0);
FIA_MatrixDestroy(matrix);
CuAssertTrue(tc, transformed_dib != NULL);
FIA_SetGreyLevelPalette(transformed_dib);
FIA_SaveFIBToFile(transformed_dib, TEST_DATA_OUTPUT_DIR "Drawing/TestFIA_AffineTransorm32bitScaleTest.bmp", BIT24);
FreeImage_Unload(dib1);
FreeImage_Unload(dib2);
FreeImage_Unload(transformed_dib);
}
static void
TestFIA_Colour32bitLineTest(CuTest* tc)
{
const char *file = TEST_DATA_DIR "bumblebee.jpg";
FIBITMAP *src = FIA_LoadFIBFromFile(file);
FIBITMAP *src32 = FreeImage_ConvertTo32Bits(src);
CuAssertTrue(tc, src != NULL);
FIAPOINT p1, p2, p3;
p1.x = 10;
p1.y = 10;
p2.x = 200;
p2.y = 300;
p3.x = 300;
p3.y = 300;
FIA_DrawColourLine (src32, p1, p2, FIA_RGBQUAD(255, 0, 0), 5, 0);
FIA_DrawColourLine (src32, p1, p3, FIA_RGBQUAD(0, 0, 255), 8, 1);
FIA_SaveFIBToFile(src32, TEST_DATA_OUTPUT_DIR "Drawing/TestFIA_Colour32bitLineTest.jpg", BIT24);
FreeImage_Unload(src);
FreeImage_Unload(src32);
}
///////////////////////////////////////////////////////////////////////////
///
/// @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;
}
bool Image::load(const char* filename)
{
const uint32_t argb_r = 0xFF000000u;
const uint32_t argb_g = 0x00FF0000u;
const uint32_t argb_b = 0x0000FF00u;
const uint32_t argb_a = 0x000000FFu;
FREE_IMAGE_FORMAT format;
FIBITMAP* bitmap;
FIBITMAP* rgbamap;
int32_t w, h;
// Unload if image already loaded to protect from memory leak
unload();
// Get filetype
format = FreeImage_GetFileType(filename);
if (format == FIF_UNKNOWN)
{
fprintf(stderr, "Failed to ascertain filetype of %s\n",
filename);
return false;
}
// Load image
bitmap = FreeImage_Load(format, filename);
if (bitmap == nullptr)
{
fprintf(stderr, "Failed to load %s\n", filename);
return false;
}
// Get width and height
w = FreeImage_GetWidth(bitmap);
h = FreeImage_GetHeight(bitmap);
// Convert to RGBA if not already
rgbamap = FreeImage_ConvertTo32Bits(bitmap);
int32_t scan_width = FreeImage_GetPitch(rgbamap);
// Make copy
int32_t size = h * scan_width;
_pixels = malloc(size);
FreeImage_ConvertToRawBits((BYTE*)_pixels, bitmap, scan_width, 32, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK, true);
_width = w;
_height = h;
// Unload FreeImage bitmaps
FreeImage_Unload(bitmap);
FreeImage_Unload(rgbamap);
return true;
}
void * RebGLSkinManager::LoadTexture(std::string filename)
{
FREE_IMAGE_FORMAT formato = FreeImage_GetFileType(filename.c_str(),0);//Automatocally detects the format(from over 20 formats!)
FIBITMAP* imagen = FreeImage_Load(formato, filename.c_str());
FIBITMAP* temp = imagen;
imagen = FreeImage_ConvertTo32Bits(imagen);
FreeImage_Unload(temp);
return imagen;
}
/*!
* \brief Opens the image file using the FreeImage library in the specified orientation
* and builds the 2D Texture MipMaps.
* \param pathImagefile Path to the image file.
* \param bVertFlip 1, if the image texture must be vertically flipped
* 0, otherwise
* \param bHorzFlip 1, if the image texture must be horizontally flipped
* 0, otherwise
* \return Texture ID.
*/
GLuint loadTexture(const char* pathImagefile, int bVertFlip, int bHorzFlip)
{
GLuint textureID;
FREE_IMAGE_FORMAT format = FreeImage_GetFileType(pathImagefile,0);
FIBITMAP* image = FreeImage_Load(format, pathImagefile,0);
int bRGBA = FreeImage_IsTransparent(image);
FIBITMAP* temp = image;
if(bRGBA)
{
image = FreeImage_ConvertTo32Bits(temp);
}
else
{
image = FreeImage_ConvertTo24Bits(temp);
}
FreeImage_Unload(temp);
if(bVertFlip)
{
FreeImage_FlipVertical(image);
}
if(bHorzFlip)
{
FreeImage_FlipHorizontal(image);
}
int w = FreeImage_GetWidth(image);
int h = FreeImage_GetHeight(image);
glGenTextures(1, &textureID);
glBindTexture(GL_TEXTURE_2D, textureID);
//// turn off bilinear filtering
//gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)
//gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
if(bRGBA)
{
gluBuild2DMipmaps(GL_TEXTURE_2D, 4, w, h, GL_BGRA, GL_UNSIGNED_BYTE, FreeImage_GetBits(image));
}
else
{
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, w, h, GL_BGR, GL_UNSIGNED_BYTE, FreeImage_GetBits(image));
}
FreeImage_Unload(image);
return textureID;
}
void putBmpIntoPixels(FIBITMAP * bmp, ofPixels_<PixelType> &pix, bool swapForLittleEndian = true) {
// convert to correct type depending on type of input bmp and PixelType
FIBITMAP* bmpConverted = NULL;
FREE_IMAGE_TYPE imgType = FreeImage_GetImageType(bmp);
if(sizeof(PixelType)==1 &&
(FreeImage_GetColorType(bmp) == FIC_PALETTE || FreeImage_GetBPP(bmp) < 8
|| imgType!=FIT_BITMAP)) {
if(FreeImage_IsTransparent(bmp)) {
bmpConverted = FreeImage_ConvertTo32Bits(bmp);
} else {
bmpConverted = FreeImage_ConvertTo24Bits(bmp);
}
bmp = bmpConverted;
}else if(sizeof(PixelType)==2 && imgType!=FIT_UINT16 && imgType!=FIT_RGB16 && imgType!=FIT_RGBA16){
if(FreeImage_IsTransparent(bmp)) {
bmpConverted = FreeImage_ConvertToType(bmp,FIT_RGBA16);
} else {
bmpConverted = FreeImage_ConvertToType(bmp,FIT_RGB16);
}
bmp = bmpConverted;
}else if(sizeof(PixelType)==4 && imgType!=FIT_FLOAT && imgType!=FIT_RGBF && imgType!=FIT_RGBAF){
if(FreeImage_IsTransparent(bmp)) {
bmpConverted = FreeImage_ConvertToType(bmp,FIT_RGBAF);
} else {
bmpConverted = FreeImage_ConvertToType(bmp,FIT_RGBF);
}
bmp = bmpConverted;
}
unsigned int width = FreeImage_GetWidth(bmp);
unsigned int height = FreeImage_GetHeight(bmp);
unsigned int bpp = FreeImage_GetBPP(bmp);
unsigned int channels = (bpp / sizeof(PixelType)) / 8;
unsigned int pitch = FreeImage_GetPitch(bmp);
// ofPixels are top left, FIBITMAP is bottom left
FreeImage_FlipVertical(bmp);
unsigned char* bmpBits = FreeImage_GetBits(bmp);
if(bmpBits != NULL) {
pix.setFromAlignedPixels((PixelType*) bmpBits, width, height, channels, pitch);
} else {
ofLogError("ofImage") << "putBmpIntoPixels(): unable to set ofPixels from FIBITMAP";
}
if(bmpConverted != NULL) {
FreeImage_Unload(bmpConverted);
}
#ifdef TARGET_LITTLE_ENDIAN
if(swapForLittleEndian && sizeof(PixelType) == 1) {
pix.swapRgb();
}
#endif
}
bool CTexture::Load(const char* texPath){
//if we already load texture, you have to delete previous...
if (TextureId != NULL) glDeleteTextures(1, &TextureId);
FREE_IMAGE_FORMAT format = FreeImage_GetFileType(texPath, 0);
FIBITMAP* image = FreeImage_Load(format, texPath);
if (format == FIF_UNKNOWN){
std::cout << "unknown texture format: file " << texPath << std::endl;
return false;
};
FIBITMAP* temp = image;
image = FreeImage_ConvertTo32Bits(image);
FreeImage_Unload(temp);
int w = FreeImage_GetWidth(image);
int h = FreeImage_GetHeight(image);
char* bits = (char*)FreeImage_GetBits(image);
// OpenGL stuff
/* TODO: Texture settings */
glGenTextures(1, &TextureId);
glBindTexture(GL_TEXTURE_2D, TextureId);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, (GLvoid*)bits);
/* Generate Mipmap */
glGenerateMipmap(GL_TEXTURE);
//glGenerateTextureMipmapEXT(TextureId);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
GLfloat fLargest;
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fLargest);
//glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest);
GLenum Error = glGetError();
if (Error){
std::cerr << "There was an error loading the texture" << std::endl;
return false;
}
return true;
}
