Texture* TextureReaderDevil::loadTexture(const std::string& filename, Texture::Filter filter, bool compress, bool keepPixels, bool createOGLTex, bool textureRectangle) { #ifndef GL_TEXTURE_RECTANGLE_ARB if (textureRectangle){ LERROR("Texture Rectangles not supported!"); textureRectangle = false; } #endif File* file = FileSys.open(filename); // check if file is open if (!file || !file->isOpen()) { delete file; return 0; } size_t len = file->size(); // check if file is empty if (len == 0) { delete file; return 0; } // allocate memory char* imdata = new char[len]; if (imdata == 0) { delete file; return 0; // allocation failed } file->read(imdata, len); file->close(); delete file; /* FIXME: I think the keepPixels option does not work properly -> I don't see why...afaik keepPixels has been used in some project (stefan) */ ILuint ImageName; ilGenImages(1, &ImageName); ilBindImage(ImageName); Texture* t = new Texture(); t->setName(filename); if (!ilLoadL(IL_TYPE_UNKNOWN, imdata, static_cast<ILuint>(len))) { LERROR("Failed to open via ilLoadL " << filename); delete[] imdata; delete t; return 0; } delete[] imdata; imdata = 0; t->setBpp(ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL)); // determine image format ILint devilFormat; switch (ilGetInteger(IL_IMAGE_FORMAT)) { case IL_LUMINANCE: // intensity channel only devilFormat = IL_LUMINANCE; t->setFormat(GL_LUMINANCE); break; case IL_LUMINANCE_ALPHA: // intensity-alpha channels devilFormat = IL_LUMINANCE_ALPHA; t->setFormat(GL_LUMINANCE_ALPHA); break; case IL_RGB: devilFormat = IL_RGB; // three color channels t->setFormat(GL_RGB); break; case IL_RGBA: devilFormat = IL_RGBA; // color-alpha channels t->setFormat(GL_RGBA); break; case IL_BGR: devilFormat = IL_RGB; // B-G-R ordered color channels, convert to RGB t->setFormat(GL_RGB); break; case IL_BGRA: devilFormat = IL_RGBA; // R-G-B-A ordered color channels, convert to RGBA t->setFormat(GL_RGBA); break; default: LERROR("unsupported format: " << ilGetInteger(IL_IMAGE_FORMAT) << " (" << filename << ")"); delete t; return 0; } // determine data type ILint devilDataType; switch (ilGetInteger(IL_IMAGE_TYPE)) { case IL_UNSIGNED_BYTE: devilDataType = IL_UNSIGNED_BYTE; t->setDataType(GL_UNSIGNED_BYTE); break; case IL_BYTE: devilDataType = IL_BYTE; t->setDataType(GL_BYTE); break; case IL_UNSIGNED_SHORT: devilDataType = IL_UNSIGNED_SHORT; t->setDataType(GL_UNSIGNED_SHORT); break; case IL_SHORT: devilDataType = IL_SHORT; t->setDataType(GL_SHORT); break; case IL_UNSIGNED_INT: devilDataType = IL_UNSIGNED_INT; t->setDataType(GL_UNSIGNED_INT); break; case IL_INT: devilDataType = IL_INT; t->setDataType(GL_INT); break; case IL_FLOAT: devilDataType = IL_FLOAT; t->setDataType(GL_FLOAT); break; default: LERROR("unsupported data type: " << ilGetInteger(IL_IMAGE_TYPE) << " (" << filename << ")"); delete t; return 0; } if (!ilConvertImage(devilFormat, devilDataType)) { LERROR("failed to convert loaded image: " << filename); delete t; return 0; } tgt::ivec3 dims; dims.x = ilGetInteger(IL_IMAGE_WIDTH); dims.y = ilGetInteger(IL_IMAGE_HEIGHT); dims.z = ilGetInteger(IL_IMAGE_DEPTH); t->setDimensions(dims); LDEBUG("Image dimensions: " << t->getDimensions()); tgtAssert( dims.z == 1, "depth is not equal 1"); #ifdef GL_TEXTURE_RECTANGLE_ARB if (textureRectangle) t->setType( GL_TEXTURE_RECTANGLE_ARB ); else #endif t->setType( GL_TEXTURE_2D ); t->alloc(); memcpy(t->getPixelData(), ilGetData(), t->getArraySize()); bool success; if (textureRectangle) success = createRectangleTexture(t, filter, compress, createOGLTex); else { if (dims.y == 1) success = create1DTexture(t, filter, compress, createOGLTex); else success = create2DTexture(t, filter, compress, createOGLTex); } if (!success) { ilDeleteImages(1, &ImageName); if (!keepPixels) t->setPixelData(0); delete t; return 0; } ilDeleteImages(1, &ImageName); if (!keepPixels) { delete[] t->getPixelData(); t->setPixelData(0); } return t; }
unsigned int sceneLoader::loadTexture(const char* filename) { ILuint imageID; // Create an image ID as a ULuint GLuint textureID; // Create a texture ID as a GLuint ILboolean success; // Create a flag to keep track of success/failure ILenum error; // Create a flag to keep track of the IL error state ilGenImages(1, &imageID); // Generate the image ID ilBindImage(imageID); // Bind the image std::stringstream sstm; sstm << filename; //sstm << "../Source/Models/house/" << filename; //sstm << "../Source/Models/Thor/" << filename; success = ilLoadImage((const ILstring) &sstm.str()[0]); // Load the image file // If we managed to load the image, then we can start to do things with it... if (success) { // If the image is flipped (i.e. upside-down and mirrored, flip it the right way up!) /* ILinfo ImageInfo; iluGetImageInfo(&ImageInfo); if (ImageInfo.Origin == IL_ORIGIN_UPPER_LEFT) { iluFlipImage(); }*/ // Convert the image into a suitable format to work with // NOTE: If your image contains alpha channel you can replace IL_RGB with IL_RGBA success = ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE); // Quit out if we failed the conversion if (!success) { error = ilGetError(); std::cout << "Image conversion failed - IL reports error: " << error << " - " << iluErrorString(error) << std::endl; exit(-1); } // Generate a new texture glGenTextures(1, &textureID); // Bind the texture to a name glBindTexture(GL_TEXTURE_2D, textureID); // Set texture clamping method glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); // Set texture interpolation method to use linear interpolation (no MIPMAPS) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Specify the texture specification glTexImage2D(GL_TEXTURE_2D, // Type of texture 0, // Pyramid level (for mip-mapping) - 0 is the top level ilGetInteger(IL_IMAGE_FORMAT), // Internal pixel format to use. Can be a generic type like GL_RGB or GL_RGBA, or a sized type ilGetInteger(IL_IMAGE_WIDTH), // Image width ilGetInteger(IL_IMAGE_HEIGHT), // Image height 0, // Border width in pixels (can either be 1 or 0) ilGetInteger(IL_IMAGE_FORMAT), // Format of image pixel data GL_UNSIGNED_BYTE, // Image data type ilGetData()); // The actual image data itself } else // If we failed to open the image file in the first place... { error = ilGetError(); std::cout << "Image load failed - IL reports error: " << error << " - " << iluErrorString(error) << std::endl; exit(-1); } ilDeleteImages(1, &imageID); // Because we have already copied image data into texture data we can release memory used by image. std::cout << "Texture creation successful." << std::endl; return textureID; // Return the GLuint to the texture so you can use it! }
ILuint ImageManager::GenerateGradientImage(ILuint TextureDevILID, int16_t PrimaryColorID, int16_t SecondaryColorID, int16_t BorderColorID) { ILuint TextureImageID; ilGenImages(1, &TextureImageID); ilBindImage(TextureImageID); ilCopyImage(TextureDevILID); ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE); //Load as IL_LUMINANCE to avoid convertion? uint8_t* TextureImageData = ilGetData(); uint32_t width = ilGetInteger(IL_IMAGE_WIDTH); uint32_t height = ilGetInteger(IL_IMAGE_HEIGHT); ILuint MaskImageID; ilGenImages(1, &MaskImageID); ilBindImage(MaskImageID); ilTexImage(width, height, 1, 4, IL_BGRA, IL_UNSIGNED_BYTE, NULL); uint8_t* MaskImageData = ilGetData(); ColorData* PrimaryColor = DATA->getColorData(PrimaryColorID); ColorData* SecondaryColor = DATA->getColorData(SecondaryColorID); uint32_t bpp = ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL); if(SecondaryColor != NULL) { for(uint32_t i = 0; i < width; i++) { for(uint32_t j = 0; j < height; j++) { MaskImageData[(i * width * bpp) + (j * bpp) + 0] = SecondaryColor->getBlue(); // Blue MaskImageData[(i * width * bpp) + (j * bpp) + 1] = SecondaryColor->getGreen(); // Green MaskImageData[(i * width * bpp) + (j * bpp) + 2] = SecondaryColor->getRed(); // Red MaskImageData[(i * width * bpp) + (j * bpp) + 3] = 255 - TextureImageData[(i * width) + j]; // Alpha } } } ILuint NewImageID; ilGenImages(1, &NewImageID); ilBindImage(NewImageID); ilTexImage(width, height, 1, 4, IL_BGRA, IL_UNSIGNED_BYTE, NULL); uint8_t* NewImageData = ilGetData(); if(PrimaryColor != NULL) { for(uint32_t i = 0; i < width; i++) { for(uint32_t j = 0; j < height; j++) { NewImageData[(i * width * bpp) + (j * bpp) + 0] = PrimaryColor->getBlue(); // Blue NewImageData[(i * width * bpp) + (j * bpp) + 1] = PrimaryColor->getGreen(); // Green NewImageData[(i * width * bpp) + (j * bpp) + 2] = PrimaryColor->getRed(); // Red NewImageData[(i * width * bpp) + (j * bpp) + 3] = 255; // Alpha } } } ilOverlayImage(MaskImageID, 0, 0, 0); if (BorderColorID != -1) { ApplyBorder(NewImageID, BorderColorID); } return NewImageID; }
SMFMap::SMFMap(std::string smfname) { std::vector<ILuint> tiles_images; std::vector<std::string> tile_files; metalmap = NULL; heightmap = NULL; typemap = NULL; minimap = NULL; vegetationmap = NULL; m_tiles = NULL; FILE * smffile = fopen(smfname.c_str(),"rb"); if ( !smffile ) { throw CannotLoadSmfFileException(); } SMFHeader hdr; fread(&hdr,sizeof(hdr),1,smffile); if ( strncmp(hdr.magic,"spring map file",15) > 0 ) { fclose(smffile); throw InvalidSmfFileException(); } mapx = hdr.mapx; mapy = hdr.mapy; m_minh = hdr.minHeight; m_maxh = hdr.maxHeight; m_smfname = smfname; m_doclamp = true; m_th = 0; m_comptype = COMPRESS_REASONABLE; m_smooth = false; texture = new Image(); texture->AllocateRGBA((mapx/128)*1024,(mapy/128)*1024); std::cout << "Loading metal map..." << std::endl; metalmap = new Image(); metalmap->AllocateLUM(mapx/2,mapy/2); fseek(smffile,hdr.metalmapPtr,SEEK_SET); fread(metalmap->datapointer,mapx/2*mapy/2,1,smffile); std::cout << "Loading heightmap..." << std::endl; heightmap = new Image(); heightmap->AllocateLUM(mapx+1,mapy+1); heightmap->ConvertToLUMHDR();//TODO: Allocate directly HDR fseek(smffile,hdr.heightmapPtr,SEEK_SET); fread(heightmap->datapointer,(mapx+1)*(mapy+1)*2,1,smffile); heightmap->FlipVertical(); std::cout << "Loading type map..." << std::endl; typemap = new Image(); typemap->AllocateLUM(mapx/2,mapy/2); fseek(smffile,hdr.typeMapPtr,SEEK_SET); fread(typemap->datapointer,mapx/2*mapy/2,1,smffile); typemap->FlipVertical(); std::cout << "Loading minimap..." << std::endl; minimap = new Image(); uint8_t * dxt1data = new uint8_t[699064]; fseek(smffile,hdr.minimapPtr,SEEK_SET); fread(dxt1data,699064,1,smffile); ilBindImage(minimap->image); ilTexImageDxtc(1024,1024,1,IL_DXT1,dxt1data); ilDxtcDataToImage(); std::cout << "Extracting main texture..." << std::endl; int *tilematrix = new int[mapx/4 * mapy/4]; fseek(smffile,hdr.tilesPtr,SEEK_SET); MapTileHeader thdr; fread(&thdr,sizeof(thdr),1,smffile); while ( tile_files.size() < thdr.numTileFiles ) { tile_files.push_back(""); char byte; int numtiles; fread(&numtiles,4,1,smffile); fread(&byte,1,1,smffile); while ( byte != 0 ) { tile_files[tile_files.size()-1].append(1,byte); fread(&byte,1,1,smffile); } } for ( std::vector<std::string>::iterator it = tile_files.begin(); it != tile_files.end(); it++ ) { std::cout << "Opening " << *it << std::endl; FILE* smtfile = fopen((*it).c_str(),"rb"); if ( !smtfile ) { fclose(smffile); delete [] tilematrix; throw CannotOpenSmtFileException(); } TileFileHeader smthdr; fread(&smthdr,sizeof(smthdr),1,smtfile); if ( strncmp(smthdr.magic,"spring tilefile",14) ) { fclose(smffile); fclose(smtfile); delete [] tilematrix; throw InvalidSmtFileException(); } for ( int i = 0; i < smthdr.numTiles; i++ ) { ILuint tile = ilGenImage(); fread(dxt1data,680,1,smtfile); ilBindImage(tile); ilTexImageDxtc(32,32,1,IL_DXT1,dxt1data); ilDxtcDataToImage(); tiles_images.push_back(tile); } fclose(smtfile); } std::cout << "Tiles @ " << ftell(smffile) << std::endl; fread(tilematrix,mapx/4 * mapy/4 * 4,1,smffile); ilBindImage(texture->image); unsigned int * texdata = (unsigned int *)ilGetData(); std::cout << "Blitting tiles..." << std::endl; for ( int y = 0; y < mapy/4; y++ ) { std::cout << "Row " << y << " of " << mapy/4 << std::endl; for ( int x = 0; x < mapx/4; x++ ) { if ( tilematrix[y*(mapx/4)+x] >= tiles_images.size() ) { std::cerr << "Warning: tile " << tilematrix[y*(mapx/4)+x] << " out of range" << std::endl; continue; } //ilBlit(tiles_images[tilematrix[y*(mapx/4)+x]],x*32,y*32,0,0,0,0,32,32,1); ilBindImage(tiles_images[tilematrix[y*(mapx/4)+x]]); unsigned int * data = (unsigned int *)ilGetData(); int r2 = 0; for ( int y2 = y*32; y2 < y*32+32; y2++ )//FAST blitting { /*for ( int x2 = y*32; x2 < y*32+32; x2++ ) { }*/ memcpy(&texdata[y2*texture->w+x*32],&data[r2*32],32*4); r2++; } } } texture->FlipVertical(); std::cout << "Loading features..." << std::endl; fseek(smffile,hdr.featurePtr,SEEK_SET); MapFeatureHeader mfhdr; fread(&mfhdr,sizeof(mfhdr),1,smffile); //-32767.0f+f->rotation/65535.0f*360 std::vector<std::string> feature_types; while ( feature_types.size() < mfhdr.numFeatureType ) { feature_types.push_back(""); char byte; fread(&byte,1,1,smffile); while ( byte != 0 ) { feature_types[feature_types.size()-1].append(1,byte); fread(&byte,1,1,smffile); } } for ( int i = 0; i < mfhdr.numFeatures; i++ ) { MapFeatureStruct f; fread(&f,sizeof(f),1,smffile); if ( f.featureType >= feature_types.size() ) { std::cerr << "Warning: invalid feature type " << f.featureType << std::endl; continue; } AddFeature(feature_types[f.featureType],f.xpos,f.ypos,f.zpos,-32767.0f+f.rotation/65535.0f*360); } fclose(smffile); delete [] dxt1data; delete [] tilematrix; }
GLuint Renderer::loadTexture(const std::string &fname) { ILuint imageID; GLuint textureID; ILboolean success; ILenum error; ilGenImages(1, &imageID); ilBindImage(imageID); success = ilLoadImage(fname.c_str()); if (success) { ILinfo ImageInfo; iluGetImageInfo(&ImageInfo); if (ImageInfo.Origin == IL_ORIGIN_UPPER_LEFT) { iluFlipImage(); } success = ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE); if (!success) { error = ilGetError(); return 0; } glGenTextures(1, &textureID); glBindTexture(GL_TEXTURE_2D, textureID); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_FORMAT), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), 0, ilGetInteger(IL_IMAGE_FORMAT), GL_UNSIGNED_BYTE, ilGetData()); } else { error = ilGetError(); return 0; } ilDeleteImages(1, &imageID); return textureID; }
// loads image bool CImage::Load(const char *fname) { assert(fname != NULL); //printf(">>> %s\n", fname); // unload old image Unload(); // init devil ilInit(); // create image ILuint img; ilGenImages(1, &img); ilBindImage(img); // correct origin ilOriginFunc(IL_ORIGIN_LOWER_LEFT); ilEnable(IL_ORIGIN_SET); // convert palette ilEnable(IL_CONV_PAL); //ilutEnable(ILUT_OPENGL_CONV); // load image if (!ilLoadImage(fname)) { ilDeleteImages(1, &img); g_errmsg = "Format not recognised or file corrupted."; return false; } else { // copy info width = ilGetInteger(IL_IMAGE_WIDTH); height = ilGetInteger(IL_IMAGE_HEIGHT); frags = ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL); GLint maxsize; glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize); if (width > maxsize || height > maxsize) { g_errmsg = "Image dimension larger than "; char shitstream[10]; sprintf(shitstream, "%i", (int)maxsize ); g_errmsg += shitstream; g_errmsg += " not supported by graphics driver!"; return false; } //printf(">>> %ix%i*%i\n", width, height, frags); int ilfmt; switch (frags) { case 1: ilfmt = IL_LUMINANCE; break; case 2: ilfmt = IL_LUMINANCE_ALPHA; break; case 3: ilfmt = IL_RGB; break; case 4: ilfmt = IL_RGBA; break; default: ilfmt = IL_RGB; break; } // convert if (!ilConvertImage(ilfmt, IL_UNSIGNED_BYTE)) { ilDeleteImages(1, &img); g_errmsg = "Failed to convert image!"; return false; } // opengl texture target = GL_TEXTURE_2D; //target = GL_TEXTURE_RECTANGLE_ARB; // todo: for compat mode? intformat = ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL); format = ilGetInteger(IL_IMAGE_FORMAT); type = GL_UNSIGNED_BYTE; } // create texture glGenTextures(1, &texname); glBindTexture(target, texname); // load image glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexImage2D(target, 0, intformat, width, height, 0, format, type, ilGetData() ); // generate mipmaps if (g_genmipmaps) { glGenerateMipmap(GL_TEXTURE_2D); mipmaps = CountMipmaps( width, height ); } else { mipmaps = 1; } // set texture params Refresh(); // unload image ilDeleteImages(1, &img); /* // determine target & images int images = 0; if (cubemap) { target = GL_TEXTURE_CUBE_MAP; } else { target = GL_TEXTURE_2D; } // determine texture format GLint intformat; switch (frags) { case 1: format = GL_ALPHA; intformat = GL_ALPHA8; break; case 3: format = GL_BGR; intformat = GL_RGB8; break; case 4: format = GL_BGRA; intformat = GL_RGBA8; break; } // mipmapping if (mipmap) { glTexParameteri(target, GL_GENERATE_MIPMAP, GL_TRUE); } else { glTexParameteri(target, GL_GENERATE_MIPMAP, GL_FALSE); } // determine upload target int uptarget = 0; if (cubemap) { if (i == 5) uptarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X; if (i == 4) uptarget = GL_TEXTURE_CUBE_MAP_NEGATIVE_X; if (i == 2) uptarget = GL_TEXTURE_CUBE_MAP_POSITIVE_Y; if (i == 3) uptarget = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y; if (i == 1) uptarget = GL_TEXTURE_CUBE_MAP_POSITIVE_Z; if (i == 0) uptarget = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; } else { uptarget = GL_TEXTURE_2D; } // upload texture image glTexImage2D(uptarget, 0, intformat, width, height, 0, format, GL_UNSIGNED_BYTE, data); } */ // copy filename filename = fname; // set flag loaded = true; // success return true; }
int GLText::LoadFont(char* fname, int Width, int Height) { ScreenWidth = Width; ScreenHeight = Height; unsigned img; ilGenImages(1, &img); ilBindImage(img); if (ilLoadImage(fname) == false) { printf("Cannot load image file %s - %d\n", fname, ilGetError()); return 1; } glGenTextures(1, &fontTexture); glBindTexture(GL_TEXTURE_2D, fontTexture); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), 0, ilGetInteger(IL_IMAGE_FORMAT), GL_UNSIGNED_BYTE, ilGetData()); 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, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); ilDeleteImages(1, &img); char data[256]; memset(data, 0, 256); strcpy(data, fname); int len = strlen(data); data[len] = 0; data[len - 1] = 't'; data[len - 2] = 'a'; data[len - 3] = 'd'; FILE* f = 0; f = fopen(data, "rb"); if (!f) { printf("Cannot load character spacing file %s", data); return 1; } fread(charSpace, 1, 256, f); fclose(f); return 0; }
void GraphicsCore::GenerateTexture(std::string path){ ILuint texid; GLuint tex; ilGenImages(1,&texid); ilBindImage(texid); if(ilLoadImage(path.c_str())){ std::cout<<"texture "<<path<<" loaded\n"; ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); }else{ std::cout << "Problems converting image" <<path<<"\n"; } glGenTextures(1,&tex); glBindTexture(GL_TEXTURE_2D, tex); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_NEAREST); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), 0, IL_RGBA,GL_UNSIGNED_BYTE, ilGetData()); ilDeleteImage(texid); TextureDatabase.insert(std::pair<std::string,GLuint>(path,tex)); }
GLuint ReadTexture() { GLuint tex; glGenTextures(1, &tex); glBindTexture(GL_TEXTURE_2D, tex); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); ILuint img; ilInit(); ilGenImages(1, &img); ilBindImage(img); ILboolean success = ilLoadImage((const ILstring)"gv2.png"); if(success) { success = ilConvertImage(IL_RGBA,IL_UNSIGNED_BYTE); glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT),0, ilGetInteger(IL_IMAGE_FORMAT), GL_UNSIGNED_BYTE, ilGetData()); } ilDeleteImages(1, &img); return tex; }
int LoadGLTextures(const aiScene* sc) { ILboolean success; //ilInit(); /* Initialization of DevIL */ //e' gia' inizializzato in InitGL nel main /* getTexture Filenames and Numb of Textures */ for (unsigned int m=0; m<sc->mNumMaterials; m++) { int texIndex = 0; aiString path; // filename aiReturn texFound = sc->mMaterials[m]->GetTexture(aiTextureType_DIFFUSE, texIndex, &path); while (texFound == AI_SUCCESS) { if (textureIdMap.find(path.data)==textureIdMap.end()) //la texture non e' ancora caricata nella mappa { textureIdMap[path.data] = NULL; //fill map with textures, pointers still NULL yet } texIndex++; texFound = sc->mMaterials[m]->GetTexture(aiTextureType_DIFFUSE, texIndex, &path); } } int numTextures = (int) textureIdMap.size(); /* array with DevIL image IDs */ ILuint* imageIds = NULL; imageIds = new ILuint[numTextures]; /* generate DevIL Image IDs */ ilGenImages(numTextures, imageIds); /* Generation of numTextures image names */ /* create and fill array with GL texture ids */ textureIds = new GLuint[numTextures]; glGenTextures(numTextures, textureIds); /* Texture name generation */ /* define texture path */ //std::string texturepath = "../../../test/models/Obj/"; /* get iterator */ std::map<std::string, GLuint*>::iterator itr = textureIdMap.begin(); int i=0; for (; itr != textureIdMap.end(); ++i, ++itr) { if (itr->second==NULL) //solo se la texture non e' ancora stata caricata { //save IL image ID std::string filename = (*itr).first; // get filename (*itr).second = &textureIds[i]; // save texture id for filename in map ilBindImage(imageIds[i]); /* Binding of DevIL image name */ std::string fileloc = basepath + filename; /* Loading of image */ success = ilLoadImage((const char *)fileloc.c_str()); //fprintf(stdout,"Loading Image: %s\n", fileloc.data()); if (success) /* If no error occured: */ { success = ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE); /* Convert every colour component into unsigned byte. If your image contains alpha channel you can replace IL_RGB with IL_RGBA */ if (!success) { /* Error occured */ fprintf(stderr,"Couldn't convert image"); return -1; } //glGenTextures(numTextures, &textureIds[i]); /* Texture name generation */ glBindTexture(GL_TEXTURE_2D, textureIds[i]); /* Binding of texture name */ //redefine standard texture values glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); /* We will use linear interpolation for magnification filter */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); /* We will use linear interpolation for minifying filter */ glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), 0, ilGetInteger(IL_IMAGE_FORMAT), GL_UNSIGNED_BYTE, ilGetData()); /* Texture specification */ } else { /* Error occured */ fprintf(stderr,"Couldn't load Image: %s\n", fileloc.data()); } } } ilDeleteImages(numTextures, imageIds); /* Because we have already copied image data into texture data we can release memory used by image. */ //Cleanup delete [] imageIds; imageIds = NULL; //return success; return TRUE; }
GLuint TextureUtils::createTexture(const GLchar *path){ ilInit(); ILuint image = ilGenImage(); ilBindImage(image); ILboolean loadSuccess = ilLoadImage(path); if(!loadSuccess){ std::cerr<<"Failed to load image: "<<path<<std::endl; ilBindImage(NULL); ilDeleteImage(image); return NULL; } ILboolean convertSuccess = ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); if(!convertSuccess){ std::cerr<<"Failed to convert image: "<<path<<std::endl; ilBindImage(NULL); ilDeleteImage(image); return NULL; } GLuint texture; glGenTextures(1, &texture); glBindTexture(GL_TEXTURE_2D, texture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_FORMAT), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), 0, ilGetInteger(IL_IMAGE_FORMAT), ilGetInteger(IL_IMAGE_TYPE), ilGetData()); glBindTexture(GL_TEXTURE_2D, NULL); ilBindImage(NULL); ilDeleteImage(image); return texture; }
void CBitmap::Load(string filename, unsigned char defaultAlpha) { if(mem!=0) { delete[] mem; mem = NULL; } if(filename.find(".dds")!=string::npos){ ddsimage = new nv_dds::CDDSImage(); ddsimage->load(filename); type = BitmapTypeDDS; return; } type = BitmapTypeStandar; ilInit(); ilOriginFunc(IL_ORIGIN_UPPER_LEFT); ilEnable(IL_ORIGIN_SET); if(mem != NULL) delete [] mem; CFileHandler file(filename); if(file.FileExists() == false) { xsize = 1; ysize = 1; mem=new unsigned char[4]; memset(mem, 0, 4); return; } unsigned char *buffer = new unsigned char[file.FileSize()]; file.Read(buffer, file.FileSize()); ILuint ImageName = 0; ilGenImages(1, &ImageName); ilBindImage(ImageName); const bool success = ilLoadL(IL_TYPE_UNKNOWN, buffer, file.FileSize()); delete [] buffer; if(success == false) { xsize = 1; ysize = 1; mem=new unsigned char[4]; memset(mem, 0, 4); return; } bool noAlpha=ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL)!=4; ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); xsize = ilGetInteger(IL_IMAGE_WIDTH); ysize = ilGetInteger(IL_IMAGE_HEIGHT); mem = new unsigned char[xsize * ysize * 4]; // ilCopyPixels(0,0,0,xsize,ysize,0,IL_RGBA,IL_UNSIGNED_BYTE,mem); memcpy(mem, (unsigned char *) ilGetData() , xsize * ysize * 4); ilDeleteImages(1, &ImageName); if(noAlpha){ for(int y=0;y<ysize;++y){ for(int x=0;x<xsize;++x){ mem[(y*xsize+x)*4+3]=defaultAlpha; } } } }
bool CBitmap::Load(std::string const& filename, unsigned char defaultAlpha) { bool noAlpha = true; delete[] mem; mem = NULL; #ifndef BITMAP_NO_OPENGL textype = GL_TEXTURE_2D; #endif // !BITMAP_NO_OPENGL if (filename.find(".dds") != std::string::npos) { type = BitmapTypeDDS; xsize = 0; ysize = 0; channels = 0; #ifndef BITMAP_NO_OPENGL ddsimage = new nv_dds::CDDSImage(); bool status = ddsimage->load(filename); if (status) { xsize = ddsimage->get_width(); ysize = ddsimage->get_height(); channels = ddsimage->get_components(); switch (ddsimage->get_type()) { case nv_dds::TextureFlat : textype = GL_TEXTURE_2D; break; case nv_dds::Texture3D : textype = GL_TEXTURE_3D; break; case nv_dds::TextureCubemap : textype = GL_TEXTURE_CUBE_MAP; break; case nv_dds::TextureNone : default : break; } } return status; #else return false; #endif // !BITMAP_NO_OPENGL } type = BitmapTypeStandardRGBA; channels = 4; CFileHandler file(filename); if (file.FileExists() == false) { Alloc(1, 1); return false; } unsigned char* buffer = new unsigned char[file.FileSize() + 2]; file.Read(buffer, file.FileSize()); boost::mutex::scoped_lock lck(devilMutex); ilOriginFunc(IL_ORIGIN_UPPER_LEFT); ilEnable(IL_ORIGIN_SET); ILuint ImageName = 0; ilGenImages(1, &ImageName); ilBindImage(ImageName); const bool success = !!ilLoadL(IL_TYPE_UNKNOWN, buffer, file.FileSize()); ilDisable(IL_ORIGIN_SET); delete[] buffer; if (success == false) { xsize = 1; ysize = 1; mem = new unsigned char[4]; mem[0] = 255; // Red allows us to easily see textures that failed to load mem[1] = 0; mem[2] = 0; mem[3] = 255; // Non Transparent return false; } noAlpha = (ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL) != 4); ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); xsize = ilGetInteger(IL_IMAGE_WIDTH); ysize = ilGetInteger(IL_IMAGE_HEIGHT); mem = new unsigned char[xsize * ysize * 4]; //ilCopyPixels(0, 0, 0, xsize, ysize, 0, IL_RGBA, IL_UNSIGNED_BYTE, mem); memcpy(mem, ilGetData(), xsize * ysize * 4); ilDeleteImages(1, &ImageName); if (noAlpha) { for (int y=0; y < ysize; ++y) { for (int x=0; x < xsize; ++x) { mem[((y*xsize+x) * 4) + 3] = defaultAlpha; } } } return true; }
bool Texture1D::loadFromFile(const std::string& filename, I32 filter, I32 wrapMode, bool mipmap) { UI32 image, texSize; // Load Image ILDEBUG(ilGenImages(1, &image)); ILDEBUG(ilBindImage(image)); bool success = ILDEBUG(ilLoadImage(filename.c_str())); if(success) { m_name = filename; UI32 texWidth = ILDEBUG(ilGetInteger(IL_IMAGE_WIDTH)); UI32 texHeight = ILDEBUG(ilGetInteger(IL_IMAGE_HEIGHT)); texSize = texWidth * texHeight; ILDEBUG(ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE)); UI8 *textureData = ILDEBUG(ilGetData()); I32 minFilter; if (filter == ODIN_LINEAR && mipmap) { minFilter = ODIN_LINEAR_MIPMAP_LINEAR; } else if (filter == ODIN_NEAREST && mipmap) { minFilter = ODIN_NEAREST_MIPMAP_LINEAR; } success = loadFromMemory(texSize, ODIN_RGBA, ODIN_RGBA, ODIN_UNSIGNED_BYTE, minFilter, filter, wrapMode, textureData, mipmap); UI32 bytesPerPixel = ILDEBUG(ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL)); std::string imageFormat; UI32 imgFormat = ILDEBUG(ilGetInteger(IL_IMAGE_FORMAT)); switch(imgFormat) { case IL_COLOR_INDEX : imageFormat = "IL_COLOR_INDEX"; break; case IL_ALPHA : imageFormat = "IL_ALPHA"; break; case IL_RGB : imageFormat = "IL_RGB"; break; case IL_RGBA : imageFormat = "IL_RGBA"; break; case IL_BGR : imageFormat = "IL_BGR"; break; case IL_BGRA : imageFormat = "IL_BGRA"; break; case IL_LUMINANCE : imageFormat = "IL_LUMINANCE"; break; case IL_LUMINANCE_ALPHA : imageFormat = "IL_LUMINANCE_ALPHA"; break; } std::string imageType; UI32 imgType = ILDEBUG(ilGetInteger(IL_IMAGE_TYPE)); switch(imgType) { case IL_BYTE : imageType = "IL_BYTE"; break; case IL_UNSIGNED_BYTE : imageType = "IL_UNSIGNED_BYTE"; break; case IL_SHORT : imageType = "IL_SHORT"; break; case IL_UNSIGNED_SHORT : imageType = "IL_UNSIGNED_SHORT"; break; case IL_INT : imageType = "IL_INT"; break; case IL_UNSIGNED_INT : imageType = "IL_UNSIGNED_INT"; break; case IL_FLOAT : imageType = "IL_FLOAT"; break; case IL_DOUBLE : imageType = "IL_DOUBLE"; break; case IL_HALF : imageType = "IL_HALF"; break; } LOG_INFO("DEVIL: Image texture successfully loaded: %s\n" "Width: %d, Height: %d, Bytes per Pixel: %d\n" "Format: %s, Data type: %s" , filename.c_str(), texWidth, texHeight, bytesPerPixel, imageFormat.c_str(), imageType.c_str()); } else { m_name = "Default"; LOG_ERROR("DEVIL: Could not load image: %s. Switching to default texture", filename.c_str()); texSize = 1; UI8 data[] = {255,255,255,255}; success = loadFromMemory(texSize, ODIN_RGBA, ODIN_RGBA, ODIN_UNSIGNED_BYTE, ODIN_NEAREST, ODIN_NEAREST, ODIN_CLAMP_TO_EDGE, data, false); } ILDEBUG(ilDeleteImages(1, &image)); return success; }
//--------------------------------------------------------------------- void LoadTexture( const std::string& _filename, Texture2D& _texture, bool _srgb, bool _allocateMipmap, bool _verbose) { try { ilInit(); ILuint imgH; ilGenImages(1, &imgH); ilBindImage(imgH); if(!ilLoadImage((const ILstring)_filename.c_str())) { Error("Load image error : file does not exist (%s)",_filename.c_str()); } if(_verbose) { Info("Load image : %s",_filename.c_str()); } // Convert all to RGBA. TODO Need improvement ... GLenum format; bool convert = false; ILenum target; switch(ilGetInteger(IL_IMAGE_FORMAT)) { case IL_RGB : format = GL_RGBA; convert=true; target = IL_RGBA; break; case IL_RGBA : format = GL_RGBA; break; case IL_BGR : format = GL_RGBA; convert=true; target = IL_RGBA; break; case IL_BGRA : format = GL_RGBA; convert=true; target = IL_RGBA; break; case IL_LUMINANCE : format = GL_RGBA; convert=true; target = IL_RGBA; break; case IL_COLOUR_INDEX : format = GL_RGBA; convert=true; target = IL_RGBA; break; case IL_ALPHA : format = GL_RGBA; convert=true; target = IL_RGBA; break; case IL_LUMINANCE_ALPHA : format = GL_RGBA; convert=true; target = IL_RGBA; break; default : Error("Load image error : unsupported format (%s)",_filename.c_str()); } GLenum type; switch(ilGetInteger(IL_IMAGE_TYPE)) { case IL_UNSIGNED_BYTE : type = GL_UNSIGNED_BYTE; break; case IL_FLOAT : type = GL_FLOAT; break; //case IL_BYTE : type = GL_BYTE; break; //case IL_SHORT : type = GL_SHORT; break; //case IL_UNSIGNED_SHORT: type = GL_UNSIGNED_SHORT; break; //case IL_INT : type = GL_INTEGER; break; //case IL_UNSIGNED_INT : type = GL_UNSIGNED_INT; break; //case IL_DOUBLE : Error("Load image error : double data are not supported (%s)",_filename.c_str()); break; default : Error("Load image error : unsupported data (%s)",_filename.c_str()); } if(convert) ilConvertImage(target, ilGetInteger(IL_IMAGE_TYPE)); // Flip image ILinfo ImageInfo; iluGetImageInfo(&ImageInfo); if( ImageInfo.Origin == IL_ORIGIN_UPPER_LEFT ) { iluFlipImage(); if(_verbose) Info("Flip image"); } switch(type) { case GL_UNSIGNED_BYTE : { if(_srgb) { _texture.Allocate( GL_SRGB8_ALPHA8, ilGetInteger(IL_IMAGE_WIDTH),ilGetInteger(IL_IMAGE_HEIGHT),_allocateMipmap); if(_verbose) Info("Allocate texture - format:GL_SRGB8_ALPHA8, w:%d, h:%d, mipmap:%s",ilGetInteger(IL_IMAGE_WIDTH),ilGetInteger(IL_IMAGE_HEIGHT), (_allocateMipmap?"TRUE":"FALSE") ); } else { _texture.Allocate( GL_RGBA8, ilGetInteger(IL_IMAGE_WIDTH),ilGetInteger(IL_IMAGE_HEIGHT),_allocateMipmap); if(_verbose) Info("Allocate texture - format:GL_RGBA8, w:%d, h:%d, mipmap:%s",ilGetInteger(IL_IMAGE_WIDTH),ilGetInteger(IL_IMAGE_HEIGHT), (_allocateMipmap?"TRUE":"FALSE") ); } } break; case GL_FLOAT : { if(_srgb) Warning("Try to convert to SRGB, but texture format is not compatible"); _texture.Allocate( GL_RGBA32F, ilGetInteger(IL_IMAGE_WIDTH),ilGetInteger(IL_IMAGE_HEIGHT),_allocateMipmap); if(_verbose) Info("Allocate texture - format:GL_RGBA32F, w:%d, h:%d, mipmap:%s",ilGetInteger(IL_IMAGE_WIDTH),ilGetInteger(IL_IMAGE_HEIGHT), (_allocateMipmap?"TRUE":"FALSE") ); } break; default : { Error("Load image error : unsupported data (%s)",_filename.c_str()); } } _texture.Fill(format,type,ilGetData()); ilDeleteImages(1, &imgH); ilShutDown(); } catch (const std::exception &e) { Error("Unable to read image file \"%s\": %s",_filename.c_str(),e.what()); } }
// helper function for derived classes // loads an image and defines an 8-bit RGBA texture unsigned int VSResourceLib::loadRGBATexture(std::string filename, bool mipmap, bool compress, GLenum aFilter, GLenum aRepMode) { ILboolean success; unsigned int imageID; GLuint textureID = 0; // Load Texture Map ilGenImages(1, &imageID); ilBindImage(imageID); /* Binding of DevIL image name */ ilEnable(IL_ORIGIN_SET); ilOriginFunc(IL_ORIGIN_LOWER_LEFT); success = ilLoadImage((ILstring)filename.c_str()); if (!success) { VSLOG(sLogError, "Couldn't load texture: %s", filename.c_str()); // The operation was not sucessfull // hence free image and texture ilDeleteImages(1, &imageID); return 0; } // add information to the log VSLOG(sLogInfo, "Texture Loaded: %s", filename.c_str()); printf("Width: %d, Height %d, Bytes per Pixel %d", ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL)); std::string s; switch(ilGetInteger(IL_IMAGE_FORMAT)) { case IL_COLOR_INDEX : s = "IL_COLOR_INDEX"; break; case IL_ALPHA : s = "IL_ALPHA"; break; case IL_RGB : s = "IL_RGB"; break; case IL_RGBA : s = "IL_RGBA"; break; case IL_BGR : s = "IL_BGR"; break; case IL_BGRA : s = "IL_BGRA"; break; case IL_LUMINANCE : s = "IL_LUMINANCE"; break; case IL_LUMINANCE_ALPHA : s = "IL_LUMINANCE_ALPHA"; break; } printf(" Format %s", s.c_str()); switch(ilGetInteger(IL_IMAGE_TYPE)) { case IL_BYTE : s = "IL_BYTE"; break; case IL_UNSIGNED_BYTE : s = "IL_UNSIGNED_BYTE"; break; case IL_SHORT : s = "IL_SHORT"; break; case IL_UNSIGNED_SHORT : s = "IL_UNSIGNED_SHORT"; break; case IL_INT : s = "IL_INT"; break; case IL_UNSIGNED_INT : s = "IL_UNSIGNED_INT"; break; case IL_FLOAT : s = "IL_FLOAT"; break; case IL_DOUBLE : s = "IL_DOUBLE"; break; case IL_HALF : s = "IL_HALF"; break; } printf(" Data type: %s\n", s.c_str()); /* Convert image to RGBA */ ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); // Set filters GLenum minFilter = aFilter; if (aFilter == GL_LINEAR && mipmap) { minFilter = GL_LINEAR_MIPMAP_LINEAR; } else if (aFilter == GL_NEAREST && mipmap){ minFilter = GL_NEAREST_MIPMAP_LINEAR; } GLenum type; if (compress) type = GL_RGBA; else type = GL_COMPRESSED_RGBA; /* Create and load textures to OpenGL */ glGenTextures(1, &textureID); /* Texture name generation */ glBindTexture(GL_TEXTURE_2D, textureID); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, aFilter); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, aRepMode); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, aRepMode); glTexImage2D(GL_TEXTURE_2D, 0, type, ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), 0, GL_RGBA, GL_UNSIGNED_BYTE, ilGetData()); // Mipmapping? if (mipmap) glGenerateMipmap(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D,0); /* Because we have already copied image data into texture data we can release memory used by image. */ ilDeleteImages(1, &imageID); return textureID; }
//----------------------------------------------------------------------- void ILUtil::fromOgre(const PixelBox &src) { // ilTexImage http://openil.sourceforge.net/docs/il/f00059.htm ILFormat ifmt = OgreFormat2ilFormat( src.format ); if(src.isConsecutive() && ifmt.isValid()) { // The easy case, the buffer is laid out in memory just like // we want it to be and is in a format DevIL can understand directly // We could even save the copy if DevIL would let us ilTexImage(static_cast<ILuint>(src.getWidth()), static_cast<ILuint>(src.getHeight()), static_cast<ILuint>(src.getDepth()), ifmt.numberOfChannels, ifmt.format, ifmt.type, src.data); } else if(ifmt.isValid()) { // The format can be understood directly by DevIL. The only // problem is that ilTexImage expects our image data consecutively // so we cannot use that directly. // Let DevIL allocate the memory for us, and copy the data consecutively // to its memory ilTexImage(static_cast<ILuint>(src.getWidth()), static_cast<ILuint>(src.getHeight()), static_cast<ILuint>(src.getDepth()), ifmt.numberOfChannels, ifmt.format, ifmt.type, 0); PixelBox dst(src.getWidth(), src.getHeight(), src.getDepth(), src.format, ilGetData()); PixelUtil::bulkPixelConversion(src, dst); } else { // Here it gets ugly. We're stuck with a pixel format that DevIL // can't do anything with. We will do a bulk pixel conversion and // then feed it to DevIL anyway. The problem is finding the best // format to convert to. // most general format supported by OGRE and DevIL PixelFormat fmt = PixelUtil::hasAlpha(src.format)?PF_FLOAT32_RGBA:PF_FLOAT32_RGB; // Make up a pixel format // We don't have to consider luminance formats as they have // straight conversions to DevIL, just weird permutations of RGBA an LA int depths[4]; PixelUtil::getBitDepths(src.format, depths); // Native endian format with all bit depths<8 can safely and quickly be // converted to 24/32 bit if(PixelUtil::isNativeEndian(src.format) && depths[0]<=8 && depths[1]<=8 && depths[2]<=8 && depths[3]<=8) { if(PixelUtil::hasAlpha(src.format)) { fmt = PF_A8R8G8B8; } else { fmt = PF_R8G8B8; } } // Let DevIL allocate the memory for us, then do the conversion ourselves ifmt = OgreFormat2ilFormat( fmt ); ilTexImage(static_cast<ILuint>(src.getWidth()), static_cast<ILuint>(src.getHeight()), static_cast<ILuint>(src.getDepth()), ifmt.numberOfChannels, ifmt.format, ifmt.type, 0); PixelBox dst(src.getWidth(), src.getHeight(), src.getDepth(), fmt, ilGetData()); PixelUtil::bulkPixelConversion(src, dst); } }
// helper function for derived classes // loads an image and defines an 8-bit RGBA texture unsigned int VSResourceLib::loadCubeMapTexture( std::string posX, std::string negX, std::string posY, std::string negY, std::string posZ, std::string negZ) { ILboolean success; unsigned int imageID; GLuint textureID = 0; std::string files[6]; files[0] = posX; files[1] = negX; files[2] = posY; files[3] = negY; files[4] = posZ; files[5] = negZ; glGenTextures(1, &textureID); /* Texture name generation */ glBindTexture(GL_TEXTURE_CUBE_MAP, textureID); // Load Textures for Cube Map glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); ilGenImages(1, &imageID); ilBindImage(imageID); /* Binding of DevIL image name */ for (int i = 0; i < 6; ++i) { ilEnable(IL_ORIGIN_SET); ilOriginFunc(IL_ORIGIN_LOWER_LEFT); success = ilLoadImage((ILstring)files[i].c_str()); if (!success) { VSLOG(sLogError, "Couldn't load texture: %s", files[i].c_str()); // The operation was not sucessfull // hence free image and texture ilDeleteImages(1, &imageID); return 0; } /* Convert image to RGBA */ ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); /* Create and load textures to OpenGL */ glTexImage2D(faceTarget[i], 0, GL_RGBA, ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), 0, GL_RGBA, GL_UNSIGNED_BYTE, ilGetData()); VSLOG(sLogInfo, "Texture Loaded: %s", files[i].c_str()); } VSLOG(sLogInfo, "Cube Map Loaded Successfully"); glBindTexture(GL_TEXTURE_CUBE_MAP,0); /* Because we have already copied image data into texture data we can release memory used by image. */ ilDeleteImages(1, &imageID); // add information to the log return textureID; }
ILboolean GenSides() { ILubyte *Buffer, *Data, Bpp, Bpc; ILuint TempImage; ILenum Format, Type; ILint SizePlane, Bps, c, y, z, i; ilActiveImage(ActiveImage); Bpp = ilGetInteger(IL_IMAGE_BPP); Bpc = ilGetInteger(IL_IMAGE_BPC); Format = ilGetInteger(IL_IMAGE_FORMAT); Type = ilGetInteger(IL_IMAGE_TYPE); // Front TexID1 = ilutGLBindTexImage(); Width = ilGetInteger(IL_IMAGE_WIDTH); Height = ilGetInteger(IL_IMAGE_HEIGHT); Depth = ilGetInteger(IL_IMAGE_DEPTH); ilGenImages(1, &TempImage); SizePlane = ilGetInteger(IL_IMAGE_PLANESIZE); SizePlane = Width * Height * Bpp * Bpc; Bps = Width * Bpp * Bpc; Data = ilGetData(); // Left i = 0; Buffer = (ILubyte*)malloc(Height * Depth * Bpp * Bpc); for (y = 0; y < Height; y++) { for (z = 0; z < Depth; z++) { for (c = 0; c < Bpp * Bpc; c++) { Buffer[i++] = Data[z * SizePlane + y * Bps + c]; } } } ilBindImage(TempImage); ilTexImage(Depth, Height, 1, Bpp, Format, Type, Buffer); TexID2 = ilutGLBindTexImage(); free(Buffer); // Right ilBindImage(ImgId); ilActiveImage(ActiveImage); i = 0; Buffer = (ILubyte*)malloc(Height * Depth * Bpp * Bpc); for (y = 0; y < Height; y++) { for (z = 0; z < Depth; z++) { for (c = 0; c < Bpp * Bpc; c++) { Buffer[i++] = Data[z * SizePlane + y * Bps + (Width - 1) * Bpp * Bpc + c]; } } } ilBindImage(TempImage); ilTexImage(Depth, Height, 1, Bpp, Format, Type, Buffer); TexID3 = ilutGLBindTexImage(); free(Buffer); // Back ilBindImage(ImgId); ilActiveImage(ActiveImage); Buffer = (ILubyte*)malloc(Width * Height * Bpp * Bpc); ilCopyPixels(0, 0, Depth-1, Width, Height, 1, Format, Type, Buffer); ilBindImage(TempImage); ilTexImage(Width, Height, 1, Bpp, Format, Type, Buffer); TexID4 = ilutGLBindTexImage(); free(Buffer); //ilDeleteImages(1, &ImgId); ilDeleteImages(1, &TempImage); ilBindImage(ImgId); return IL_TRUE; }
int NMS_TextureManager::LoadTexture (const char* sFilename,char* textureName) { if(_DEBUG) { sprintf_s (m_Singleton->m_sMessage, m_Singleton->m_iMessageSize, "NMS_TextureManager::Trying to load [%s]\n", sFilename); LOG.write(m_sMessage,LOG_DEBUG); } if (ilGetInteger(IL_VERSION_NUM) < IL_VERSION) { LOG.write("NMS_TextureManager::Wrong DevIL version!\n",LOG_ERROR); return -1; } //Create the hash on which to compare to see if we have loaded the same two file twice shaMap hash; //Open the file provided and check for the SHA1 hash to see if we have already another texture like this FILE *fp=NULL; ILubyte *Lump; //Open the texture file fopen_s(&fp,sFilename,"rb"); if (!fp) { LOG.write("NMS_TextureManager::Cannot open the texture file!\n",LOG_ERROR); return -1; } //Calculate the size of the file long fileSize= nmsFileManagement::FileSize(fp); if (fileSize<=0) { LOG.write("NMS_TextureManager::Negative file size for the texture!\n",LOG_ERROR); return -1; } //Convert the file read to a Lump file to be used by DevIL Lump = (ILubyte*)LEVEL_ALLOC->allocMem(fileSize, MEM_TEXTURE); fseek(fp, 0, SEEK_SET); fread(Lump, 1, fileSize, fp); fclose(fp); if(_DEBUG) LOG.write("NMS_TextureManager::Lump created correctly!\n",LOG_DEBUG); //Create the sha1 hash=nmsSha1::returnSha1(Lump,fileSize); textStruct imageToBeAdded=checkForHash(hash,textureName); GLuint image=NULL; ILuint texid=NULL; //Just a basic check. If both the textID AND the hash are different from NULL that means that //we have already the texture and we just want to change the name into the map if(imageToBeAdded.textID!=NULL && imageToBeAdded.hash!=NULL) { textureMap[textureName]=imageToBeAdded; image=textureMap[textureName].textID; } else { //It's the same texture with the same name, do nothing! if(imageToBeAdded.textID==NULL && imageToBeAdded.hash!=NULL) { image=textureMap[textureName].textID; } //It's a different texture with the same name, warn the user and exit else if(imageToBeAdded.textID==-1) {throw 0;} else { //It's a new image, load it ILboolean success; ilInit(); // Initialization of DevIL ilGenImages(1, &texid); // Generation of one image name ilBindImage(texid); // Binding of image name success = ilLoadL(IL_TYPE_UNKNOWN,Lump,fileSize); // Loading of image "image.jpg" //USA iLoadImageF //free(Lump); if (success) // If no error occured: { success = ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE); // Convert every colour component into // unsigned byte. If your image contains alpha channel you can replace IL_RGB with IL_RGBA if (!success) { LOG.write("NMS_TextureManager::Error in converting the texture in the proper format!\n",LOG_ERROR); ilDeleteImages(1, &texid); // Error occured return -1; } //Create the new image glGenTextures(1, &image); // Texture name generation glBindTexture(GL_TEXTURE_2D, image); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // We will use linear interpolation for magnification filter glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // We will use linear interpolation for minifying filter glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), 0, ilGetInteger(IL_IMAGE_FORMAT), GL_UNSIGNED_BYTE, ilGetData()); // Texture specification if(_DEBUG) LOG.write("NMS_TextureManager::Texture loaded from Lump!\n",LOG_DEBUG); } else { // Error occured LOG.write("NMS_TextureManager::Error in loading the texture from the Lump!\n",LOG_ERROR); ilDeleteImages(1, &texid); return -1; } } } //Pick the image that has been created to be used in our context textureMap[textureName].textID=image; textureMap[textureName].hash=hash; if(_DEBUG) { sprintf_s (m_Singleton->m_sMessage, m_Singleton->m_iMessageSize, "NMS_TextureManager::Loaded [%s] without issues!\n", sFilename); LOG.write(m_sMessage,LOG_DEBUG); } //glBindTexture(GL_TEXTURE_2D, image); // Binding of texture name ilDeleteImages(1, &texid); //Close the file we are done with it fclose(fp); cerr << "Texture id" << textureMap[textureName].textID; return textureMap[textureName].textID; return textureMap[textureName].textID; }
int LoadGLTextures(const aiScene* scene) { ILboolean success; /* Before calling ilInit() version should be checked. */ if (ilGetInteger(IL_VERSION_NUM) < IL_VERSION) { ILint test = ilGetInteger(IL_VERSION_NUM); /// wrong DevIL version /// std::string err_msg = "Wrong DevIL version. Old devil.dll in system32/SysWow64?"; char* cErr_msg = (char *) err_msg.c_str(); abortGLInit(cErr_msg); return -1; } ilInit(); /* Initialization of DevIL */ if (scene->HasTextures()) abortGLInit("Support for meshes with embedded textures is not implemented"); /* getTexture Filenames and Numb of Textures */ for (unsigned int m=0; m<scene->mNumMaterials; m++) { int texIndex = 0; aiReturn texFound = AI_SUCCESS; aiString path; // filename while (texFound == AI_SUCCESS) { texFound = scene->mMaterials[m]->GetTexture(aiTextureType_DIFFUSE, texIndex, &path); textureIdMap[path.data] = NULL; //fill map with textures, pointers still NULL yet texIndex++; } } int numTextures = textureIdMap.size(); /* array with DevIL image IDs */ ILuint* imageIds = NULL; imageIds = new ILuint[numTextures]; /* generate DevIL Image IDs */ ilGenImages(numTextures, imageIds); /* Generation of numTextures image names */ /* create and fill array with GL texture ids */ textureIds = new GLuint[numTextures]; glGenTextures(numTextures, textureIds); /* Texture name generation */ /* define texture path */ //std::string texturepath = "../../../test/models/Obj/"; /* get iterator */ std::map<std::string, GLuint*>::iterator itr = textureIdMap.begin(); for (int i=0; i<numTextures; i++) { //save IL image ID std::string filename = (*itr).first; // get filename (*itr).second = &textureIds[i]; // save texture id for filename in map itr++; // next texture ilBindImage(imageIds[i]); /* Binding of DevIL image name */ std::string fileloc = basepath + filename; /* Loading of image */ success = ilLoadImage(fileloc.c_str()); if (success) /* If no error occured: */ { success = ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE); /* Convert every colour component into unsigned byte. If your image contains alpha channel you can replace IL_RGB with IL_RGBA */ if (!success) { /* Error occured */ abortGLInit("Couldn't convert image"); return -1; } //glGenTextures(numTextures, &textureIds[i]); /* Texture name generation */ glBindTexture(GL_TEXTURE_2D, textureIds[i]); /* Binding of texture name */ //redefine standard texture values glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); /* We will use linear interpolation for magnification filter */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); /* We will use linear interpolation for minifying filter */ glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), 0, ilGetInteger(IL_IMAGE_FORMAT), GL_UNSIGNED_BYTE, ilGetData()); /* Texture specification */ } else { /* Error occured */ MessageBox(NULL, ("Couldn't load Image: " + fileloc).c_str() , "ERROR", MB_OK | MB_ICONEXCLAMATION); } } ilDeleteImages(numTextures, imageIds); /* Because we have already copied image data into texture data we can release memory used by image. */ //Cleanup delete [] imageIds; imageIds = NULL; //return success; return TRUE; }
void CBitmap::Load(string const& filename, unsigned char defaultAlpha) { delete[] mem; mem = NULL; ilOriginFunc(IL_ORIGIN_UPPER_LEFT); ilEnable(IL_ORIGIN_SET); if(mem != NULL) delete [] mem; CFileHandler file(filename); if(file.FileExists() == false) { xsize = 1; ysize = 1; mem=new unsigned char[4]; memset(mem, 0, 4); return; } unsigned char *buffer = new unsigned char[file.FileSize()]; file.Read(buffer, file.FileSize()); ILuint ImageName = 0; ilGenImages(1, &ImageName); ilBindImage(ImageName); const bool success = ilLoadL(IL_TYPE_UNKNOWN, buffer, file.FileSize()); delete [] buffer; if(success == false) { xsize = 1; ysize = 1; mem=new unsigned char[4]; memset(mem, 0, 4); return; } bool noAlpha=ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL)!=4; #if !defined(__APPLE__) // Temporary fix to allow testing of everything // else until i get a quicktime image loader written ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); xsize = ilGetInteger(IL_IMAGE_WIDTH); ysize = ilGetInteger(IL_IMAGE_HEIGHT); mem = new unsigned char[xsize * ysize * 4]; // ilCopyPixels(0,0,0,xsize,ysize,0,IL_RGBA,IL_UNSIGNED_BYTE,mem); memcpy(mem, ilGetData(), xsize * ysize * 4); #else xsize = 4; ysize = 4; mem = new unsigned char[xsize * ysize * 4]; #endif ilDeleteImages(1, &ImageName); if(noAlpha){ for(int y=0;y<ysize;++y){ for(int x=0;x<xsize;++x){ mem[(y*xsize+x)*4+3]=defaultAlpha; } } } }
ColladaTexture::ColladaTexture(FCDImage * _image) { image = _image; // Create an image container in DevIL. ILuint imageId; ilGenImages(1, &imageId); ilBindImage(imageId); // do it square // reduce it if it is necessaryt // test this //GL_MAX_TEXTURE_SIZE. // initializate some variables hasAlphaChannel = false; wchar_t orig[512]; const size_t newsize = 256; char nstring[newsize]; #ifdef _WIN32 // convert fstring to char*, amazing code based on http://msdn2.microsoft.com/en-us/library/ms235631(vs.80).aspx size_t convertedChars = 0; swprintf(orig, 512,L"%s", image->GetFilename().c_str() ); size_t origsize = wcslen(orig) + 1; wcstombs_s(&convertedChars, nstring, origsize, orig, _TRUNCATE); #else swprintf(orig, 512,L"%s", image->GetFilename().c_str() ); const wchar_t * origTmp = &orig[0]; wcsnrtombs( nstring, &origTmp, 512, 256, NULL); #endif texturePathName = nstring; wprintf(L"* added texture: %s", (wchar_t*)(image->GetFilename().c_str())); printf(" name: %s\n", image->GetDaeId().c_str()); // Read in the image file into DevIL. if (!ilLoadImage(nstring)) { wchar_t error_message[256]; swprintf(error_message, 256, L"This texture could not be opened: %s\n", (wchar_t*)(image->GetFilename().c_str())); wprintf(error_message); ILenum err = ilGetError(); if (IL_NO_ERROR != err) { printf("- ilGetError() = %x", err); } ilDeleteImages(1, &imageId); textureId = -1; } else { // resize if necessary ProcessDevilImage(); // gl work glGenTextures(1, &textureId); /* Texture name generation */ GLenum error; if ((error = glGetError()) != GL_NO_ERROR) { printf("OpenGL Error: %x\n", error); } glBindTexture(GL_TEXTURE_2D, textureId); /* Binding of texture name */ // if 4 channels, the last one is the alpha channel if (ilGetInteger(IL_IMAGE_CHANNELS) == 4) hasAlphaChannel = true; // create mipmaps and upload texture to video card memory gluBuild2DMipmaps ( GL_TEXTURE_2D, ilGetInteger(IL_IMAGE_CHANNELS), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), ilGetInteger(IL_IMAGE_FORMAT), GL_UNSIGNED_BYTE, ilGetData() ); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT); glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); printf("texture size: %d x %d\n", ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT)); // release memory, now opengl have it ! ilDeleteImages(1, &imageId); } }
bool Model::initMaterials(const char* fileName, const aiScene* scene){ ILboolean success; /* initialization of DevIL */ ilInit(); //debug line to confirm material number //std::cout << "material number: " << materialNumber << "\n"; //debug line to check number of materials //std::cout << "Materials found " << materialNumber << "\n"; int texIndex = 0; aiString path; // filename aiReturn texFound = scene->mMaterials[materialNumber]->GetTexture(aiTextureType_DIFFUSE, texIndex, &path); //very strange, but texFound seems to contain the opposite of what we'd expect if (texFound) { //std::cout << "No texture image found \n Using default texture"; textureIdMap["assets/models/textures/default.jpg"] = 0; //std::cout << path.data << "\n\n"; } else { //fill map with textures, OpenGL image ids set to 0 // Extract the file name out of the file path std::string file = path.data; std::string::size_type SlashIndex = file.find_last_of("/"); file = file.substr(SlashIndex+1); //and prepend the directory we want to find texture images file.insert(0, "assets/models/textures/"); textureIdMap[file.c_str()] = 0; } //because we only have 1 texture per mesh, probably don't need this //given more time can strip this down to load our 1 texture for our object int numTextures = textureIdMap.size(); /* create and fill array with DevIL texture ids */ ILuint* imageIds = new ILuint[numTextures]; ilGenImages(numTextures, imageIds); /* create and fill array with GL texture ids */ GLuint* textureIds = new GLuint[numTextures]; glGenTextures(numTextures, textureIds); /* Texture name generation */ /* get iterator */ std::map<std::string, GLuint>::iterator itr = textureIdMap.begin(); int i=0; for (; itr != textureIdMap.end(); ++i, ++itr) { //save IL image ID std::string filename = (*itr).first; // get filename (*itr).second = textureIds[i]; // save texture id for filename in map ilBindImage(imageIds[i]); /* Binding of DevIL image name */ ilEnable(IL_ORIGIN_SET); ilOriginFunc(IL_ORIGIN_LOWER_LEFT); success = ilLoadImage((ILstring)filename.c_str()); if (success) { /* Convert image to RGBA */ ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); //save our texture data to be bound later width = ilGetInteger(IL_IMAGE_WIDTH); height = ilGetInteger(IL_IMAGE_HEIGHT); texId = textureIds[i]; ILubyte* texDataBytes = ilGetData(); texData = new ILubyte [ilGetInteger(IL_IMAGE_SIZE_OF_DATA)]; for (int i=0; i < ilGetInteger(IL_IMAGE_SIZE_OF_DATA); i++){ texData[i] = texDataBytes[i]; } } else printf("Couldn't load Image: %s\n Please make sure all texture images are located in assets/models/textures/ folder!", filename.c_str()); } /* Because we have already copied image data into texture data we can release memory used by image. */ ilDeleteImages(numTextures, imageIds); //Cleanup delete [] imageIds; delete [] textureIds; return true; }
bool CBitmap::Load(std::string const& filename, unsigned char defaultAlpha) { #ifndef BITMAP_NO_OPENGL ScopedTimer timer("Textures::CBitmap::Load"); #endif bool noAlpha = true; delete[] mem; mem = NULL; #ifndef BITMAP_NO_OPENGL textype = GL_TEXTURE_2D; #endif // !BITMAP_NO_OPENGL if (filename.find(".dds") != std::string::npos) { #ifndef BITMAP_NO_OPENGL type = BitmapTypeDDS; xsize = 0; ysize = 0; channels = 0; ddsimage = new nv_dds::CDDSImage(); bool status = ddsimage->load(filename); if (status) { xsize = ddsimage->get_width(); ysize = ddsimage->get_height(); channels = ddsimage->get_components(); switch (ddsimage->get_type()) { case nv_dds::TextureFlat : textype = GL_TEXTURE_2D; break; case nv_dds::Texture3D : textype = GL_TEXTURE_3D; break; case nv_dds::TextureCubemap : textype = GL_TEXTURE_CUBE_MAP; break; case nv_dds::TextureNone : default : break; } } return status; #else // !BITMAP_NO_OPENGL AllocDummy(); //allocate a dummy texture, as dds aren't supported in headless return true; #endif // !BITMAP_NO_OPENGL } type = BitmapTypeStandardRGBA; channels = 4; CFileHandler file(filename); if (file.FileExists() == false) { AllocDummy(); return false; } unsigned char* buffer = new unsigned char[file.FileSize() + 2]; file.Read(buffer, file.FileSize()); boost::mutex::scoped_lock lck(devilMutex); ilOriginFunc(IL_ORIGIN_UPPER_LEFT); ilEnable(IL_ORIGIN_SET); ILuint ImageName = 0; ilGenImages(1, &ImageName); ilBindImage(ImageName); { // do not signal floating point exceptions in devil library ScopedDisableFpuExceptions fe; const bool success = !!ilLoadL(IL_TYPE_UNKNOWN, buffer, file.FileSize()); ilDisable(IL_ORIGIN_SET); delete[] buffer; if (success == false) { AllocDummy(); return false; } } noAlpha = (ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL) != 4); ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); xsize = ilGetInteger(IL_IMAGE_WIDTH); ysize = ilGetInteger(IL_IMAGE_HEIGHT); mem = new unsigned char[xsize * ysize * 4]; //ilCopyPixels(0, 0, 0, xsize, ysize, 0, IL_RGBA, IL_UNSIGNED_BYTE, mem); memcpy(mem, ilGetData(), xsize * ysize * 4); ilDeleteImages(1, &ImageName); if (noAlpha) { for (int y=0; y < ysize; ++y) { for (int x=0; x < xsize; ++x) { mem[((y*xsize+x) * 4) + 3] = defaultAlpha; } } } return true; }
int main(int argc, char *argv[]) { e_epiphany_t Epiphany, *pEpiphany; e_mem_t DRAM, *pDRAM; unsigned int msize; int row, col, cnum; ILuint ImgId; // ILenum Error; ILubyte *imdata; ILuint imsize, imBpp; unsigned int addr; size_t sz; struct timespec timer[4]; uint32_t time_p[TIMERS]; uint32_t time_d[TIMERS]; FILE *fo; // FILE *fi; int result; pEpiphany = &Epiphany; pDRAM = &DRAM; msize = 0x00400000; //get_args(argc, argv); strcpy(ar.ifname,argv[1]); strcpy(ar.elfFile,argv[2]); strcpy(ar.ofname, ar.ifname); printf("------------------------------------------------------------\n"); fo = fopen("matprt.m", "w"); if ((fo == NULL)) // || (fi == NULL)) { fprintf(stderr, "Could not open Octave file \"%s\" ...exiting.\n", "matprt.m"); exit(4); } // fo = stderr; // Connect to device for communicating with the Epiphany system // Prepare device e_set_host_verbosity(ar.verbose); e_init(NULL); e_reset_system(); e_get_platform_info(&platform); if (e_open(pEpiphany, 0, 0, platform.rows, platform.cols)) { fprintf(fo, "\nERROR: Can't establish connection to Epiphany device!\n\n"); exit(1); } if (e_alloc(pDRAM, 0x00000000, msize)) { fprintf(fo, "\nERROR: Can't allocate Epiphany DRAM!\n\n"); exit(1); } // Initialize Epiphany "Ready" state addr = offsetof(shared_buf_t, core.ready); Mailbox.core.ready = 0; e_write(pDRAM, 0, 0, addr, (void *) &(Mailbox.core.ready), sizeof(Mailbox.core.ready)); result = e_load_group(ar.elfFile, pEpiphany, 0, 0, platform.rows, platform.cols, (e_bool_t) (ar.run_target)); if (result == E_ERR) { printf("Error loading Epiphany program.\n"); exit(1); } // Check if the DevIL shared lib's version matches the executable's version. if (ilGetInteger(IL_VERSION_NUM) < IL_VERSION) { fprintf(stderr, "DevIL version is different ...exiting!\n"); exit(2); } // Initialize DevIL. ilInit(); #ifdef ILU_ENABLED iluInit(); #endif // create the coreID list init_coreID(pEpiphany, coreID, _Nside, _Nside, 0x808); // Generate the main image name to use, bind it and load the image file. ilGenImages(1, &ImgId); ilBindImage(ImgId); if (!ilLoadImage(ar.ifname))//ar.ifname { fprintf(stderr, "Could not open input image file \"%s\" ...exiting.\n", ar.ifname); exit(3); } // Display the image's dimensions to the end user. /* printf("Width: %d Height: %d Depth: %d Bpp: %d\n\n", ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), ilGetInteger(IL_IMAGE_DEPTH), ilGetInteger(IL_IMAGE_BITS_PER_PIXEL)); */ imdata = ilGetData(); imsize = ilGetInteger(IL_IMAGE_WIDTH) * ilGetInteger(IL_IMAGE_HEIGHT); imBpp = ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL); if (imsize != (_Sfft * _Sfft)) { printf("Image file size is different from %dx%d ...exiting.\n", _Sfft, _Sfft); exit(5); } // Extract image data into the A matrix. for (unsigned int i=0; i<imsize; i++) { Mailbox.A[i] = (float) imdata[i*imBpp] + 0.0 * I; } fprintf(fo, "\n"); // Generate operand matrices based on a provided seed matrix_init(0); #ifdef _USE_DRAM_ // Copy operand matrices to Epiphany system addr = DRAM_BASE + offsetof(shared_buf_t, A[0]); sz = sizeof(Mailbox.A); fprintf(fo, "%% Writing A[%ldB] to address %08x...\n", sz, addr); e_write(addr, (void *) Mailbox.A, sz); addr = DRAM_BASE + offsetof(shared_buf_t, B[0]); sz = sizeof(Mailbox.B); fprintf(fo, "%% Writing B[%ldB] to address %08x...\n", sz, addr); e_write(addr, (void *) Mailbox.B, sz); #else // Copy operand matrices to Epiphany cores' memory fprintf(fo, "%% Writing image to Epiphany\n"); sz = sizeof(Mailbox.A) / _Ncores; for (row=0; row<(int) platform.rows; row++) for (col=0; col<(int) platform.cols; col++) { addr = BankA_addr; fflush(stdout); cnum = e_get_num_from_coords(pEpiphany, row, col); // printf( "Writing A[%uB] to address %08x...\n", sz, addr); fprintf(fo, "%% Writing A[%uB] to address %08x...\n", sz, (coreID[cnum] << 20) | addr); fflush(fo); e_write(pEpiphany, row, col, addr, (void *) &Mailbox.A[cnum * _Score * _Sfft], sz); } #endif // Call the Epiphany fft2d() function fprintf(fo, "%% GO!\n"); fflush(stdout); fflush(fo); clock_gettime(CLOCK_MONOTONIC, &timer[0]); fft2d_go(pDRAM); clock_gettime(CLOCK_MONOTONIC, &timer[1]); fprintf(fo, "%% Done!\n\n"); fflush(stdout); fflush(fo); // Read time counters // printf( "Reading time count...\n"); fprintf(fo, "%% Reading time count...\n"); addr = 0x7128+0x4*2 + offsetof(core_t, time_p[0]); sz = TIMERS * sizeof(uint32_t); e_read(pEpiphany, 0, 0, addr, (void *) (&time_p[0]), sz); // for (int i=0; i<TIMERS; i++) // printf("time_p[%d] = %u\n", i, time_p[i]); time_d[2] = time_p[7] - time_p[2]; // FFT setup time_d[3] = time_p[2] - time_p[3]; // bitrev (x8) time_d[4] = time_p[3] - time_p[4]; // FFT-1D (x8) time_d[5] = time_p[4] - time_p[5]; // corner-turn time_d[6] = time_p[7] - time_p[8]; // FFT-2D time_d[7] = time_p[6] - time_p[7]; // LPF time_d[9] = time_p[0] - time_p[9]; // Total cycles fprintf(fo, "%% Finished calculation in %u cycles (%5.3f msec @ %3.0f MHz)\n\n", time_d[9], (time_d[9] * 1000.0 / eMHz), (eMHz / 1e6)); printf( "FFT2D - %7u cycles (%5.3f msec)\n", time_d[6], (time_d[6] * 1000.0 / eMHz)); printf( " FFT Setup - %7u cycles (%5.3f msec)\n", time_d[2], (time_d[2] * 1000.0 / eMHz)); printf( " BITREV - %7u cycles (%5.3f msec)\n", time_d[3], (time_d[3] * 1000.0 / eMHz)); printf( " FFT1D - %7u cycles (%5.3f msec x2)\n", time_d[4], (time_d[4] * 1000.0 / eMHz)); printf( " Corner Turn - %7u cycles (%5.3f msec)\n", time_d[5], (time_d[5] * 1000.0 / eMHz)); printf( "LPF - %7u cycles (%5.3f msec)\n", time_d[7], (time_d[7] * 1000.0 / eMHz)); fprintf(fo, "%% Reading processed image back to host\n"); // Read result matrix #ifdef _USE_DRAM_ addr = DRAM_BASE + offsetof(shared_buf_t, B[0]); sz = sizeof(Mailbox.B); printf( "Reading B[%ldB] from address %08x...\n", sz, addr); fprintf(fo, "%% Reading B[%ldB] from address %08x...\n", sz, addr); blknum = sz / RdBlkSz; remndr = sz % RdBlkSz; for (i=0; i<blknum; i++) { fflush(stdout); e_read(addr+i*RdBlkSz, (void *) ((long unsigned)(Mailbox.B)+i*RdBlkSz), RdBlkSz); } fflush(stdout); e_read(addr+i*RdBlkSz, (void *) ((long unsigned)(Mailbox.B)+i*RdBlkSz), remndr); #else // Read result matrix from Epiphany cores' memory sz = sizeof(Mailbox.A) / _Ncores; for (row=0; row<(int) platform.rows; row++) for (col=0; col<(int) platform.cols; col++) { addr = BankA_addr; fflush(stdout); cnum = e_get_num_from_coords(pEpiphany, row, col); // printf( "Reading A[%uB] from address %08x...\n", sz, addr); fprintf(fo, "%% Reading A[%uB] from address %08x...\n", sz, (coreID[cnum] << 20) | addr); fflush(fo); e_read(pEpiphany, row, col, addr, (void *) &Mailbox.B[cnum * _Score * _Sfft], sz); } #endif // Convert processed image matrix B into the image file date. for (unsigned int i=0; i<imsize; i++) { for (unsigned int j=0; j<imBpp; j++) imdata[i*imBpp+j] = cabs(Mailbox.B[i]); } // Save processed image to the output file. ilEnable(IL_FILE_OVERWRITE); if (!ilSaveImage(ar.ofname)) { fprintf(stderr, "Could not open output image file \"%s\" ...exiting.\n", ar.ofname); exit(7); } // We're done with the image, so let's delete it. ilDeleteImages(1, &ImgId); // Simple Error detection loop that displays the Error to the user in a human-readable form. // while ((Error = ilGetError())) // PRINT_ERROR_MACRO; // Close connection to device if (e_close(pEpiphany)) { fprintf(fo, "\nERROR: Can't close connection to Epiphany device!\n\n"); exit(1); } if (e_free(pDRAM)) { fprintf(fo, "\nERROR: Can't release Epiphany DRAM!\n\n"); exit(1); } fflush(fo); fclose(fo); //Returnin success if test runs expected number of clock cycles //Need to add comparison with golden reference image! printf("------------------------------------------------------------\n"); if(time_d[9]>50000) { printf( "TEST \"fft2d\" PASSED\n"); return EXIT_SUCCESS; } else { printf( "TEST \"fft2d\" FAILED\n"); return EXIT_FAILURE; } }
uint8_t* ImageManager::getImageData(ILuint DevilImageID) { ilBindImage(DevilImageID); return ilGetData(); }
void init() { bancAlto = new BancoAlto(0.6); bancBalc = new BancoBalcao(0.8); bar = Bar(1); copoV=copo_vinho(0.025); copoL=copo_largo(0.025); flt=flute(0.035); mesaQ=new MesaQuadrada(0.5,0.2); mesaR=new MesaRedonda(0.4); sofa=new Sofa(0.7,2); bil=new Bilhar(0.7); cBilhar=new CandeeiroBilhar(2,0.2); balcao=new Balcao(5,0.6,2); cLuz=new CandeeiroLuz(0.1); garr=new GarrafaAgua(0.2); garW=new GarrafaWhisky(0.2); porta=new Plano(0.5,1,10,20); GLfloat fLargest; glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fLargest); ILuint ima[N_TEX]; ilInit(); ilGenImages(N_TEX,ima); glGenTextures(N_TEX,tex); int imagew,imageh; ilBindImage(ima[MADEIRA_TEX]); ilLoadImage((ILstring)"madeira_tex.jpg"); ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); imagew=ilGetInteger(IL_IMAGE_WIDTH); imageh=ilGetInteger(IL_IMAGE_HEIGHT); imageData[MADEIRA_TEX]=ilGetData(); glBindTexture(GL_TEXTURE_2D,tex[MADEIRA_TEX]); 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_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest); gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, imagew, imageh, GL_RGBA, GL_UNSIGNED_BYTE, imageData[MADEIRA_TEX]); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_BASE_LEVEL,0); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,10); ilBindImage(ima[TECIDO_SOFA_TEX]); ilLoadImage((ILstring)"tecido_sofa_tex.jpg"); ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); imagew=ilGetInteger(IL_IMAGE_WIDTH); imageh=ilGetInteger(IL_IMAGE_HEIGHT); imageData[TECIDO_SOFA_TEX]=ilGetData(); glBindTexture(GL_TEXTURE_2D,tex[TECIDO_SOFA_TEX]); 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_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest); gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, imagew, imageh, GL_RGBA, GL_UNSIGNED_BYTE, imageData[TECIDO_SOFA_TEX]); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_BASE_LEVEL,0); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,10); ilBindImage(ima[CHAO_TEX]); ilLoadImage((ILstring)"madeira_tex_alt.jpg"); ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); imagew=ilGetInteger(IL_IMAGE_WIDTH); imageh=ilGetInteger(IL_IMAGE_HEIGHT); imageData[CHAO_TEX]=ilGetData(); glBindTexture(GL_TEXTURE_2D,tex[CHAO_TEX]); 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_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest); gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, imagew, imageh, GL_RGBA, GL_UNSIGNED_BYTE, imageData[CHAO_TEX]); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_BASE_LEVEL,0); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,10); ilBindImage(ima[PAREDES_TEX]); ilLoadImage((ILstring)"parede_tex.jpg"); ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); imagew=ilGetInteger(IL_IMAGE_WIDTH); imageh=ilGetInteger(IL_IMAGE_HEIGHT); imageData[PAREDES_TEX]=ilGetData(); glBindTexture(GL_TEXTURE_2D,tex[PAREDES_TEX]); 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_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest); gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, imagew, imageh, GL_RGBA, GL_UNSIGNED_BYTE, imageData[PAREDES_TEX]); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_BASE_LEVEL,0); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,10); ilBindImage(ima[BALCAO_TAMPO_TEX]); ilLoadImage((ILstring)"balcao_tampo_tex.jpg"); ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); imagew=ilGetInteger(IL_IMAGE_WIDTH); imageh=ilGetInteger(IL_IMAGE_HEIGHT); imageData[BALCAO_TAMPO_TEX]=ilGetData(); glBindTexture(GL_TEXTURE_2D,tex[BALCAO_TAMPO_TEX]); 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_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest); gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, imagew, imageh, GL_RGBA, GL_UNSIGNED_BYTE, imageData[BALCAO_TAMPO_TEX]); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_BASE_LEVEL,0); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,10); ilBindImage(ima[BANCO_TAMPO_TEX]); ilLoadImage((ILstring)"banco_tampo_tex.png"); ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); imagew=ilGetInteger(IL_IMAGE_WIDTH); imageh=ilGetInteger(IL_IMAGE_HEIGHT); imageData[BANCO_TAMPO_TEX]=ilGetData(); glBindTexture(GL_TEXTURE_2D,tex[BANCO_TAMPO_TEX]); 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_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest); gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, imagew, imageh, GL_RGBA, GL_UNSIGNED_BYTE, imageData[BANCO_TAMPO_TEX]); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_BASE_LEVEL,0); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,10); ilBindImage(ima[PORTA_TEX]); ilLoadImage((ILstring)"porta_tex.jpg"); ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); imagew=ilGetInteger(IL_IMAGE_WIDTH); imageh=ilGetInteger(IL_IMAGE_HEIGHT); imageData[PORTA_TEX]=ilGetData(); glBindTexture(GL_TEXTURE_2D,tex[PORTA_TEX]); 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_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest); gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, imagew, imageh, GL_RGBA, GL_UNSIGNED_BYTE, imageData[PORTA_TEX]); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_BASE_LEVEL,0); glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,10); //Create the shadow map texture glGenTextures(1, &shadowMapTexture); glBindTexture(GL_TEXTURE_2D, shadowMapTexture); 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, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); //Enable shadow comparison glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE); //Shadow comparison should be true (ie not in shadow) if r<=texture glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL); glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_ALPHA); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, shadowMapSize, shadowMapSize, 0,GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL); //Load identity modelview glMatrixMode(GL_MODELVIEW); glLoadIdentity(); //Shading states glShadeModel(GL_SMOOTH); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); glGenFramebuffers(1,&mFBO); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, mFBO); glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, shadowMapTexture, 0); glGenTextures(2, aaTexture); glBindTexture(GL_TEXTURE_2D, aaTexture[0]); 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, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, AA_LEVEL*wWidth, AA_LEVEL*wHeight, 0,GL_RGBA, GL_UNSIGNED_BYTE, NULL); glBindTexture(GL_TEXTURE_2D, aaTexture[1]); 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, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, AA_LEVEL*wWidth, AA_LEVEL*wHeight, 0,GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL); glGenFramebuffers(1,&aaFBO); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, aaFBO); glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, aaTexture[0], 0); glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_TEXTURE_2D, aaTexture[1],0); glGenTextures(1, &aaAuxTexture); glBindTexture(GL_TEXTURE_2D, aaAuxTexture); 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, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, AA_LEVEL*wWidth/2, AA_LEVEL*wHeight/2, 0,GL_RGBA, GL_UNSIGNED_BYTE, NULL); glGenFramebuffers(1,&aaAuxFBO); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, aaAuxFBO); glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, aaAuxTexture, 0); // Disable writes to the color buffer glDrawBuffer(GL_NONE); //Depth states glClearDepth(1.0f); glDepthFunc(GL_LEQUAL); //We use glScale when drawing the scene glEnable(GL_NORMALIZE); // alguns settings para OpenGL glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D,0); }
ILuint ImageManager::GeneratedOverLayImage(ILuint TextureDevILID, int16_t PrimaryColorID, int16_t BorderColorID) { ILuint TextureImageID; ilGenImages(1, &TextureImageID); ilBindImage(TextureImageID); ilCopyImage(TextureDevILID); ilConvertImage(IL_LUMINANCE_ALPHA, IL_UNSIGNED_BYTE); uint8_t* TextureImageData = ilGetData(); uint32_t width = ilGetInteger(IL_IMAGE_WIDTH); uint32_t height = ilGetInteger(IL_IMAGE_HEIGHT); ColorData* PrimaryColor = DATA->getColorData(PrimaryColorID); ILuint NewImageID; ilGenImages(1, &NewImageID); ilBindImage(NewImageID); ilTexImage(width, height, 1, 4, IL_BGRA, IL_UNSIGNED_BYTE, NULL); uint8_t* NewImageData = ilGetData(); uint32_t bpp = ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL); if(PrimaryColor != NULL) { for(uint32_t i = 0; i < width; i++) { for(uint32_t j = 0; j < height; j++) { float Base = TextureImageData[(i * width * 2) + (j * 2) + 0]; uint8_t Alpha = TextureImageData[(i * width * 2) + (j * 2) + 1]; Base /= 255.0; float OriginalBlue = PrimaryColor->getBlue(); OriginalBlue /= 255.0; float OriginalGreen = PrimaryColor->getGreen(); OriginalGreen /= 255.0; float OriginalRed = PrimaryColor->getRed(); OriginalRed /= 255.0; // coloring using overlay mode if(Base >= 0.5) { NewImageData[(i * width * bpp) + (j * bpp) + 0] = (1.0 - 2.0 * (1.0 - OriginalBlue) * (1.0 - Base)) * 255; // Blue NewImageData[(i * width * bpp) + (j * bpp) + 1] = (1.0 - 2.0 * (1.0 - OriginalGreen) * (1.0 - Base)) * 255; // Green NewImageData[(i * width * bpp) + (j * bpp) + 2] = (1.0 - 2.0 * (1.0 - OriginalRed) * (1.0 - Base)) * 255; // Red NewImageData[(i * width * bpp) + (j * bpp) + 3] = Alpha; } else { NewImageData[(i * width * bpp) + (j * bpp) + 0] = (2.0 * OriginalBlue * Base) * 255; // Blue NewImageData[(i * width * bpp) + (j * bpp) + 1] = (2.0 * OriginalGreen * Base) * 255; // Green NewImageData[(i * width * bpp) + (j * bpp) + 2] = (2.0 * OriginalRed * Base) * 255; // Red NewImageData[(i * width * bpp) + (j * bpp) + 3] = Alpha; } } } } if (BorderColorID != -1) { ApplyBorder(NewImageID, BorderColorID); } return NewImageID; }
GLuint loadCubemap(string filebase) { glActiveTexture(GL_TEXTURE0); GLuint imageID; ilGenImages(1, &imageID); ilBindImage(imageID); glGenTextures(1, &imageID); glBindTexture(GL_TEXTURE_CUBE_MAP, imageID); string suffixes[] = {"right","left","top", "bottom","back","front"}; GLuint targets[] = { GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z }; bool success; ILenum error; for (int i = 0; i < 6; i++) { string texName = filebase + "_" + suffixes[i] + ".png"; success = ilLoadImage(texName.c_str()); // Load the image file printf("LOADED %s\n", texName.c_str()); // If we managed to load the image, then we can start to do things with it... if (success) { /* // If the image is flipped (i.e. upside-down and mirrored, flip it the right way up!) ILinfo ImageInfo; iluGetImageInfo(&ImageInfo); if (ImageInfo.Origin == IL_ORIGIN_UPPER_LEFT) { iluFlipImage(); } */ // Convert the image into a suitable format to work with // NOTE: If your image contains alpha channel you can replace IL_RGB with IL_RGBA success = ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE); // Quit out if we failed the conversion if (!success) { error = ilGetError(); std::cout << "Image conversion failed - IL reports error: " << error << " - " << iluErrorString(error) << std::endl; exit(-1); } glTexImage2D(targets[i], // Type of texture 0, // Pyramid level (for mip-mapping) - 0 is the top level ilGetInteger(IL_IMAGE_FORMAT), // Internal image format ilGetInteger(IL_IMAGE_WIDTH), // Image width ilGetInteger(IL_IMAGE_HEIGHT), // Image height 0, // Border width in pixels (can either be 1 or 0) ilGetInteger(IL_IMAGE_FORMAT), // Image format (i.e. RGB, RGBA, BGR etc.) GL_UNSIGNED_BYTE, // Image data type ilGetData()); // The actual image data itself } else // If we failed to open the image file in the first place... { error = ilGetError(); std::cout << "Image load failed - IL reports error: " << error << " - " << iluErrorString(error) << std::endl; exit(-1); } ilDeleteImages(1, &imageID); // Because we have already copied image data into texture data we can release memory used by image } // Set texture clamping method glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); // Set texture interpolation method to use linear interpolation (no MIPMAPS) glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); return imageID; }