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; }