/* Loads the stereo background */ void loadStereoBackground(void) { printf("Left Background loaded = %s", leftBackground.c_str()); // Import left image FREE_IMAGE_FORMAT fImageFormatLeft = FreeImage_GetFileType(leftBackground.c_str(), 0); FIBITMAP *fBitMapLeft = FreeImage_Load(fImageFormatLeft, leftBackground.c_str(), 0); fBitMapLeft = FreeImage_ConvertTo24Bits(fBitMapLeft); glGenTextures(1, &bgLeftID); glBindTexture(GL_TEXTURE_2D, bgLeftID); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR); BYTE *bitsLeft = new BYTE[FreeImage_GetWidth(fBitMapLeft) * FreeImage_GetHeight(fBitMapLeft) * 3]; BYTE *pixelsLeft = (BYTE*)FreeImage_GetBits(fBitMapLeft); // Switch in RGB format for(int pix=0; pix<FreeImage_GetWidth(fBitMapLeft) * FreeImage_GetHeight(fBitMapLeft); pix++) { bitsLeft[pix*3+0]=pixelsLeft[pix*3+2]; bitsLeft[pix*3+1]=pixelsLeft[pix*3+1]; bitsLeft[pix*3+2]=pixelsLeft[pix*3+0]; } glTexImage2D(GL_TEXTURE_2D, 0, 3, FreeImage_GetWidth(fBitMapLeft), FreeImage_GetHeight(fBitMapLeft), 0, GL_RGB, GL_UNSIGNED_BYTE, bitsLeft); FreeImage_Unload(fBitMapLeft); delete bitsLeft; printf("Right Background loaded = %s", rightBackground.c_str()); // Import right image FREE_IMAGE_FORMAT fImageFormatRight = FreeImage_GetFileType(rightBackground.c_str(), 0); FIBITMAP *fBitMapRight = FreeImage_Load(fImageFormatRight, rightBackground.c_str(), 0); fBitMapRight = FreeImage_ConvertTo24Bits(fBitMapRight); glGenTextures(1, &bgRightID); glBindTexture(GL_TEXTURE_2D, bgRightID); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR); BYTE *bitsRight = new BYTE[FreeImage_GetWidth(fBitMapRight) * FreeImage_GetHeight(fBitMapRight) * 3]; BYTE *pixelsRight = (BYTE*)FreeImage_GetBits(fBitMapRight); // Switch in RGB format for(int pix=0; pix<FreeImage_GetWidth(fBitMapRight) * FreeImage_GetHeight(fBitMapRight); pix++) { bitsRight[pix*3+0]=pixelsRight[pix*3+2]; bitsRight[pix*3+1]=pixelsRight[pix*3+1]; bitsRight[pix*3+2]=pixelsRight[pix*3+0]; } glTexImage2D(GL_TEXTURE_2D, 0, 3, FreeImage_GetWidth(fBitMapRight), FreeImage_GetHeight(fBitMapRight), 0, GL_RGB, GL_UNSIGNED_BYTE, bitsRight); FreeImage_Unload(fBitMapRight); delete bitsRight; stereoBackground = true; }
/** * Create twitch texture */ bool CreateTexture() { const char* textureFile = "twitch.png"; FREE_IMAGE_FORMAT format = FreeImage_GetFileType(textureFile, 0); FIBITMAP* bitmap = FreeImage_Load(format, textureFile); if ( bitmap == nullptr ) { std::string filePath = std::string("..\\..\\") + textureFile; format = FreeImage_GetFileType(filePath.c_str(), 0); bitmap = FreeImage_Load(format, filePath.c_str() ); if ( bitmap == nullptr ) { ReportError("Failed to load texture"); return false; } } FIBITMAP* bitmap32 = FreeImage_ConvertTo32Bits(bitmap); int w = FreeImage_GetWidth(bitmap32); int h = FreeImage_GetHeight(bitmap32); char* buffer = (char*)FreeImage_GetBits(bitmap32); glGenTextures(1, &gTwitchTexture); glBindTexture(GL_TEXTURE_2D, gTwitchTexture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER , GL_NEAREST ); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER , GL_NEAREST ); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, (GLvoid*)buffer ); FreeImage_Unload(bitmap32); FreeImage_Unload(bitmap); if ( glGetError() != GL_NO_ERROR ) { ReportError("Failed to load texture"); glBindTexture(GL_TEXTURE_2D, 0); return false; } glBindTexture(GL_TEXTURE_2D, 0); return true; }
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 fipImage::load(const char* lpszPathName, int flag) { FREE_IMAGE_FORMAT fif = FIF_UNKNOWN; // check the file signature and get its format // (the second argument is currently not used by FreeImage) fif = FreeImage_GetFileType(lpszPathName, 0); if(fif == FIF_UNKNOWN) { // no signature ? // try to guess the file format from the file extension fif = FreeImage_GetFIFFromFilename(lpszPathName); } // check that the plugin has reading capabilities ... if((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif)) { // Free the previous dib if(_dib) { FreeImage_Unload(_dib); } // Load the file _dib = FreeImage_Load(fif, lpszPathName, flag); _bHasChanged = TRUE; if(_dib == NULL) return FALSE; return TRUE; } return FALSE; }
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 pre_lzw::do_lzw(const QDir & d){ FreeImage_Initialise(true); QString label_out = ""; QString dst = ui.lineEdit_2->text(); QString d_src = d.path(); QString serial_str = d_src.right(5); QDir dst_dir(dst); dst_dir.mkdir(serial_str); QString image_name = "", image_name_path(""), saved_name(""); int dot_pos = 0; QFileInfoList handled_images = d.entryInfoList(); QList<QFileInfo>::iterator images_iter = handled_images.begin(); FREE_IMAGE_FORMAT fif = FIF_UNKNOWN; for(; images_iter < handled_images.end(); ++images_iter){ image_name_path = (*images_iter).absoluteFilePath(); if((*images_iter).isDir()){ continue; } FIBITMAP *handled_image = 0; image_name = (*images_iter).fileName(); dot_pos = image_name.indexOf("."); saved_name = dst + "\\" + serial_str + "\\" + image_name.left(dot_pos) + "_c.tif"; label_out += saved_name + "\n"; fif = FreeImage_GetFileType(image_name_path.toStdString().c_str()); handled_image = FreeImage_Load(fif, image_name_path.toStdString().c_str()); FreeImage_Save(FIF_TIFF, handled_image, saved_name.toStdString().c_str(), TIFF_LZW); FreeImage_Unload(handled_image); } // ui.label->setText(label_out); FreeImage_DeInitialise(); }
bool CTexture::loadTexture2D(string a_sPath, bool bGenerateMipMaps) { FREE_IMAGE_FORMAT fif = FIF_UNKNOWN; FIBITMAP* dib(0); fif = FreeImage_GetFileType(a_sPath.c_str(), 0); // Check the file signature and deduce its format if(fif == FIF_UNKNOWN) // If still unknown, try to guess the file format from the file extension fif = FreeImage_GetFIFFromFilename(a_sPath.c_str()); if(fif == FIF_UNKNOWN) // If still unknown, return failure return false; if(FreeImage_FIFSupportsReading(fif)) // Check if the plugin has reading capabilities and load the file dib = FreeImage_Load(fif, a_sPath.c_str()); if(!dib) return false; BYTE* bDataPointer = FreeImage_GetBits(dib); // Retrieve the image data // If somehow one of these failed (they shouldn't), return failure 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); sPath = a_sPath; return true; // Success }
/** Test extracting a memory buffer from a memory stream */ void testAcquireMemIO(const char *lpszPathName) { // load a regular file FREE_IMAGE_FORMAT fif = FreeImage_GetFileType(lpszPathName); FIBITMAP *dib = FreeImage_Load(fif, lpszPathName, 0); // open and allocate a memory stream fipMemoryIO memIO; // save the file to memory memIO.write(FIF_PNG, dib, PNG_DEFAULT); // get the buffer from the memory stream BYTE *mem_buffer = NULL; DWORD size_in_bytes = 0; memIO.acquire(&mem_buffer, &size_in_bytes); // save the buffer in a file stream FILE *stream = fopen("buffer.png", "wb"); if(stream) { fwrite(mem_buffer, sizeof(BYTE), size_in_bytes, stream); fclose(stream); } // close and free the memory stream (memIO is destroyed) }
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 DLL_CALLCONV FreeImage_JPEGCrop(const char *src_file, const char *dst_file, int left, int top, int right, int bottom) { char crop[64]; try { // check the src file format if(FreeImage_GetFileType(src_file) != FIF_JPEG) { throw FI_MSG_ERROR_MAGIC_NUMBER; } // normalize the rectangle if(right < left) { INPLACESWAP(left, right); } if(bottom < top) { INPLACESWAP(top, bottom); } // build the crop option sprintf(crop, "%dx%d+%d+%d", right - left, bottom - top, left, top); // setup IO FilenameIO filenameIO; memset(&filenameIO, 0, sizeof(FilenameIO)); filenameIO.src_file = src_file; filenameIO.dst_file = dst_file; // perform the transformation return LosslessTransform(&filenameIO, FIJPEG_OP_NONE, crop, FALSE); } catch(const char *text) { FreeImage_OutputMessageProc(FIF_JPEG, text); return FALSE; } }
bool LoadTexture(const char* filename, //where to load the file from GLuint &texID, //does not have to be generated with glGenTextures GLenum image_format, //format the image is in GLint internal_format, //format to store the image in GLint level , //mipmapping 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); //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; //generate an OpenGL texture ID for this texture glGenTextures(1, &texID); //store the texture ID mapping //bind to the new texture ID glBindTexture(GL_TEXTURE_2D, texID); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // 线形滤波 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // 线形滤波 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); //store the texture data for OpenGL use glTexImage2D(GL_TEXTURE_2D, level, internal_format, width, height, border, image_format, GL_UNSIGNED_BYTE, bits); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); //Free FreeImage's copy of the data FreeImage_Unload(dib); //return success return true; }
//---------------------------------------------------------------- void ofImage::saveImageFromPixels(string fileName, ofPixels &pix){ if (pix.bAllocated == false){ ofLog(OF_LOG_ERROR,"error saving image - pixels aren't allocated"); return; } #ifdef TARGET_LITTLE_ENDIAN if (pix.bytesPerPixel != 1) swapRgb(pix); #endif FIBITMAP * bmp = getBmpFromPixels(pix); #ifdef TARGET_LITTLE_ENDIAN if (pix.bytesPerPixel != 1) swapRgb(pix); #endif fileName = ofToDataPath(fileName); if (pix.bAllocated == true){ FREE_IMAGE_FORMAT fif = FIF_UNKNOWN; fif = FreeImage_GetFileType(fileName.c_str(), 0); if(fif == FIF_UNKNOWN) { // or guess via filename fif = FreeImage_GetFIFFromFilename(fileName.c_str()); } if((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif)) { FreeImage_Save(fif, bmp, fileName.c_str(), 0); } } if (bmp != NULL){ FreeImage_Unload(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; }
/* * \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; }
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; }
void testAcquireMemIO(const char *lpszPathName) { FIMEMORY *hmem = NULL; // load a regular file FREE_IMAGE_FORMAT fif = FreeImage_GetFileType(lpszPathName); FIBITMAP *dib = FreeImage_Load(fif, lpszPathName, 0); // open and allocate a memory stream hmem = FreeImage_OpenMemory(); // save the file to memory FreeImage_SaveToMemory(FIF_PNG, dib, hmem, PNG_DEFAULT); FreeImage_Unload(dib); // get the buffer from the memory stream BYTE *mem_buffer = NULL; DWORD size_in_bytes = 0; FreeImage_AcquireMemory(hmem, &mem_buffer, &size_in_bytes); // save the buffer in a file stream FILE *stream = fopen("buffer.png", "wb"); if(stream) { fwrite(mem_buffer, sizeof(BYTE), size_in_bytes, stream); fclose(stream); } // close and free the memory stream FreeImage_CloseMemory(hmem); }
void TextureLoader::loadImageToGLTexture(unsigned& texture_handle, std::string const& image_path, unsigned color_format, unsigned texture_unit) { glGenTextures(1, &texture_handle); glActiveTexture(texture_unit); glBindTexture(GL_TEXTURE_2D, texture_handle); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); FIBITMAP* bitmap = FreeImage_Load( FreeImage_GetFileType(image_path.c_str(), 0), image_path.c_str()); FIBITMAP * pImage = FreeImage_ConvertTo24Bits(bitmap); int nWidth = FreeImage_GetWidth(pImage); int nHeight = FreeImage_GetHeight(pImage); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, nWidth, nHeight, 0, GL_BGR, GL_UNSIGNED_BYTE, (void*)FreeImage_GetBits(pImage)); FreeImage_Unload(pImage); }
void loadTexture(int n, GLuint texture, GLint sampler, int texUnit, const char *filename) { FREE_IMAGE_FORMAT imageFormat = FreeImage_GetFileType(filename, 0); FIBITMAP *bitmap = FreeImage_Load(imageFormat, filename, 0); unsigned int width = FreeImage_GetWidth(bitmap); unsigned int height = FreeImage_GetHeight(bitmap); unsigned char *data = FreeImage_GetBits(bitmap); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); if (texUnit == 0) { glActiveTexture(GL_TEXTURE0); g_texUnit0 = true; } else { glActiveTexture(GL_TEXTURE1); g_texUnit1 = true; } glBindTexture(GL_TEXTURE_2D, texture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); glUniform1d(sampler, texUnit); glClear(GL_COLOR_BUFFER_BIT); if (g_texUnit0 && g_texUnit1) { glDrawArrays(GL_TRIANGLE_STRIP, 0, n); } FreeImage_Unload(bitmap); }
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; }
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; }
/* Loads the background image */ void loadBackground(void) { //printf("Background image loaded %s", backgroundName.c_str()); FREE_IMAGE_FORMAT fImageFormat = FreeImage_GetFileType(backgroundName.c_str(), 0); FIBITMAP *fBitMap = FreeImage_Load(fImageFormat, backgroundName.c_str(), 0); fBitMap = FreeImage_ConvertTo24Bits(fBitMap); glGenTextures(1, &bgTextureID); glBindTexture(GL_TEXTURE_2D, bgTextureID); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR); BYTE *bits = new BYTE[FreeImage_GetWidth(fBitMap) * FreeImage_GetHeight(fBitMap) * 3]; BYTE *pixels = (BYTE*)FreeImage_GetBits(fBitMap); // Switch in RGB format for(int pix=0; pix<FreeImage_GetWidth(fBitMap) * FreeImage_GetHeight(fBitMap); pix++) { bits[pix*3+0]=pixels[pix*3+2]; bits[pix*3+1]=pixels[pix*3+1]; bits[pix*3+2]=pixels[pix*3+0]; } glTexImage2D(GL_TEXTURE_2D, 0, 3, FreeImage_GetWidth(fBitMap), FreeImage_GetHeight(fBitMap), 0, GL_RGB, GL_UNSIGNED_BYTE, bits); FreeImage_Unload(fBitMap); delete bits; background = 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; }
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; }
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); } }
VALUE rb_graffik_open(VALUE self, VALUE rb_filename) { char *filename = STR2CSTR(rb_filename); FREE_IMAGE_FORMAT fif = FIF_UNKNOWN; // Try various methods to thet the image format fif = FreeImage_GetFileType(filename, 0); if (fif == FIF_UNKNOWN) { fif = FreeImage_GetFIFFromFilename(filename); } if ((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif)) { int flags = ((fif == FIF_JPEG) ? JPEG_ACCURATE : 0); // Load the image from disk FIBITMAP *image = FreeImage_Load(fif, filename, flags); // Develop an instance for Ruby VALUE instance = Data_Wrap_Struct(self, NULL, NULL, image); // Store the image type as a FixNum rb_iv_set(instance, "@file_type", INT2FIX(fif)); // If a block is given, yield to it, if not, return the instance if (rb_block_given_p()) { return rb_ensure(rb_yield, instance, rb_graffik_close, instance); } else { return instance; } } // If we couldn't load it, throw and error rb_raise(rb_eTypeError, "Unknown file format"); }
unsigned char* loadImage(const char* _fileName, int& _width, int& _height) { FREE_IMAGE_FORMAT fif = FreeImage_GetFileType(_fileName); FIBITMAP *dib = FreeImage_Load(fif, _fileName, 0); int dimX = FreeImage_GetWidth(dib); int dimY = FreeImage_GetHeight(dib); unsigned char* result = (unsigned char*)malloc(sizeof(unsigned char) * dimX * dimY); int index = 0; for(unsigned y = 1; y <= dimY; ++y) { for(unsigned x = 0; x < dimX; ++x) { RGBQUAD pixel; bool ok = FreeImage_GetPixelColor(dib, x, dimY - y, &pixel); result[index] = method( &pixel ); ++index; } } _width = dimX; _height = dimY; return result; }
Texture::Texture(const std::string& texname) { name = texname; FIBITMAP* texture; FREE_IMAGE_FORMAT fif; const char* path = ("res/texture/"+texname).c_str(); fif = FreeImage_GetFileType(path,0); if( FreeImage_FIFSupportsReading(fif)) { texture = FreeImage_Load(fif, path); int imgWidth = FreeImage_GetWidth(texture); int imgHeight = FreeImage_GetHeight(texture); //std::cout << imgWidth << " "<< imgHeight <<"\n"; glGenTextures( 1, &t ); //std::cout << "\nACTIVE TEXTURE VALUE IS: " << GL_TEXTURE0+t << "\n"; glActiveTexture(GL_TEXTURE0); glBindTexture( GL_TEXTURE_2D, t ); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, imgWidth, imgHeight, 0, GL_BGR, GL_UNSIGNED_BYTE, (void*)FreeImage_GetBits(texture)); FreeImage_Unload(texture); std::cout << "Image file is good\n"; std::cout << "Loaded: " << texname << "\n"; } else { std::cout << "File not supported!\n"; } }
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; //clock_t begin = clock(); if(FreeImage_FIFSupportsReading(fif)) dib = FreeImage_Load(fif, sTexturePath.c_str()); if(!dib) return false; //clock_t end = clock(); //cout << end - begin << endl; 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 loadTexture(const char* filename, const unsigned int textureId) { FREE_IMAGE_FORMAT fif = FIF_UNKNOWN; FIBITMAP* dib = 0; BYTE* bits = 0; unsigned int width, height = 0; GLuint glTextureId; fif = FreeImage_GetFileType(filename, 0); dib = FreeImage_Load(fif, filename); bits = FreeImage_GetBits(dib); width = FreeImage_GetWidth(dib); height = FreeImage_GetHeight(dib); std::clog << width << " " << height << std::endl; glGenTextures(1, &glTextureId); glBindTexture(GL_TEXTURE_2D, glTextureId); frontTexture = glTextureId; gluBuild2DMipmaps(GL_TEXTURE_2D, 3, width, height, GL_BGR, GL_UNSIGNED_BYTE, bits); }
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; }