Example #1
0
    bool Image32::load_pixels_from_file_32(const char *path)
    {
        // free texture
        free_texture();
        
        // generate image
        ILuint image_id = 0;
        ilGenImages(1, &image_id);
        ilBindImage(image_id);

        //Load image
        bool loaded_image = ilLoadImage( path );
        
        if (loaded_image) {
            
            // convert image
            bool converted = ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE);
            
            if (converted == IL_TRUE)
            {
                // init dimensions
                GLuint image_width  = (GLuint)ilGetInteger(IL_IMAGE_WIDTH);
                GLuint image_height = (GLuint)ilGetInteger(IL_IMAGE_HEIGHT);
                
                GLuint texture_width = power_of_two(image_width);
                GLuint texture_height = power_of_two(image_height);
                
                if (image_width != texture_width || image_height != texture_height)
                {
                    // place image in upper left
                    iluImageParameter(ILU_PLACEMENT, ILU_UPPER_LEFT);
                    
                    // resize image
                    iluEnlargeCanvas((int)texture_width, (int)texture_height, 1);
                }
                
                // allocate memory for texture
                GLuint size = texture_height*texture_width;
                _pixels_32 = new GLuint[size];
                
                _image_width    = image_width;
                _image_height   = image_height;
                _texture_width  = texture_width;
                _texture_height = texture_height;
                
                memcpy(_pixels_32, ilGetData(), size*4);
                
                
            }
            ilDeleteImages(1,&image_id);
            
        } else {
            std::cout << "unable to load pixels from file: " << path << std::endl;
            return false;
        }

        _pixel_format = GL_RGBA;
        return true;
    }
bool LTexture::loadTextureFromFile32( std::string path )
{
    //Texture loading success
    bool textureLoaded = false;

    //Generate and set current image ID
    ILuint imgID = 0;
    ilGenImages( 1, &imgID );
    ilBindImage( imgID );

    //Load image
    ILboolean success = ilLoadImage( path.c_str() );

    //Image loaded successfully
    if( success == IL_TRUE )
    {
        //Convert image to RGBA
        success = ilConvertImage( IL_RGBA, IL_UNSIGNED_BYTE );
        if( success == IL_TRUE )
        {
            //Initialize dimensions
            GLuint imgWidth = (GLuint)ilGetInteger( IL_IMAGE_WIDTH );
            GLuint imgHeight = (GLuint)ilGetInteger( IL_IMAGE_HEIGHT );

            //Calculate required texture dimensions
            GLuint texWidth = powerOfTwo( imgWidth );
            GLuint texHeight = powerOfTwo( imgHeight );

            //Texture is the wrong size
            if( imgWidth != texWidth || imgHeight != texHeight )
            {
                //Place image at upper left
                iluImageParameter( ILU_PLACEMENT, ILU_UPPER_LEFT );

                //Resize image
                iluEnlargeCanvas( (int)texWidth, (int)texHeight, 1 );
            }

            //Create texture from file pixels
            textureLoaded = loadTextureFromPixels32( (GLuint*)ilGetData(), imgWidth, imgHeight, texWidth, texHeight );
        }

        //Delete file from memory
        ilDeleteImages( 1, &imgID );

        //Set pixel format
        mPixelFormat = GL_RGBA;
    }

    //Report error
    if( !textureLoaded )
    {
        printf( "Unable to load %s\n", path.c_str() );
    }

    return textureLoaded;
}
Example #3
0
   bool Image32::load_texture_from_file_32(const char *path)
   {
       // generate image
       ILuint image_id = 0;
       ilGenImages(1, &image_id);
       ilBindImage(image_id);
       
       //Load image
       bool got = ilLoadImage( path );
 
       
       if (got == IL_TRUE) 
       {
           // convert image
           bool converted = ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE);
           
           if (converted == IL_TRUE)
           {
               // init dimensions
               GLuint image_width  = (GLuint)ilGetInteger(IL_IMAGE_WIDTH);
               GLuint image_height = (GLuint)ilGetInteger(IL_IMAGE_HEIGHT);
               
               GLuint texture_width = power_of_two(image_width);
               GLuint texture_height = power_of_two(image_height);
               
               if (image_width != texture_width || image_height != texture_height)
               {
                   // place image in upper left
                   iluImageParameter(ILU_PLACEMENT, ILU_UPPER_LEFT);
                   
                   // resize image
                   iluEnlargeCanvas((int)texture_width, (int)texture_height, 1);
               }
               
               bool loaded = load_texture_from_pixels_32((GLuint*)ilGetData(), image_width, image_height, texture_width, texture_height);
               
               if (!loaded) {
                   std::cout << "unable to load image: " << path << std::endl;
                   return false;
               }
           }
           ilDeleteImages(1,&image_id);
       }
       _pixel_format = GL_RGBA;
       return true;
   }
std::tr1::shared_ptr<ATexture> ATextureLoader::LoadFile(const std::string& path)
{
	// try to retrieve the texture from the cache, if it exists
	std::tr1::shared_ptr<ATexture> texture_sp = ATextureCache::GetInstance()->Get(path);
	if(texture_sp != nullptr){
		return texture_sp;
	}

	unsigned int width, contentWidth, height, contentHeight;

	ILuint imageID = ilGenImage();
	ilBindImage(imageID);

	if(!ilLoadImage(path.c_str())){
		std::string error = "Fail to load file: " + path;
		throw std::exception(error.c_str());
		return nullptr;
	}

	// The content in
	width = contentWidth = ilGetInteger(IL_IMAGE_WIDTH);
	height = contentHeight = ilGetInteger(IL_IMAGE_HEIGHT);
	ILint bpp = ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL);

	// Actual texture  size padded with extra pixels, ensure width and height are power of two.
	if(!isPowerOfTwo(contentWidth))
		width = nextPowerOfTwo(contentWidth);
	if(!isPowerOfTwo(contentHeight))
		height = nextPowerOfTwo(contentHeight);

	// default background colour will be solid black
	ilClearColour(0.0f, 0.0f, 0.0f, 1.0f);

	// TODO: there is still some confusion here.......
	// flip texture problem is mentioned here: http://www.gamedev.net/topic/308200-devil-textures-upside-down/

	// Together with the ilOriginFunc in the graphics_engine.h initialize function, and followed by iLuFlipImage(). 
	// They ensure the image data will be correctly loaded and place on top left corner. And the data will be always stored from top left corner.
	iluImageParameter(ILU_PLACEMENT, ILU_UPPER_LEFT);
	// bitmap image seems like storing data upside down, its origin is on the lower left.
	// jpg, png data seems like using upper left as the origin.
	if (ilGetInteger(IL_IMAGE_ORIGIN) == IL_ORIGIN_UPPER_LEFT){
		// This is for fixing the loaded image upside down in OpenGL...
		iluFlipImage();
	}

	// set the canvas size.
	iluEnlargeCanvas(width, height, bpp);

	// Allocate the memory for the image data.
	GLubyte* buffer = new GLubyte[width * height * bpp];
	// Copy the loaded image data into the texture data depending on how many bytes per pixel
	if(bpp == 4){
		ilCopyPixels(0, 0, 0, width, height, 1, IL_RGBA, GL_UNSIGNED_BYTE, buffer);
	}
	else if(bpp == 3){
		ilCopyPixels(0, 0, 0, width, height, 1, IL_RGB, GL_UNSIGNED_BYTE, buffer);
	}
	else{
		std::string error = "Loading process, byte per pixel error, bpp: "+bpp;
		throw std::exception(error.c_str());	
	}

	// Delete the devIL image data
	ilDeleteImage(imageID);

	// create a brand new texture to use
	// put the texture into the texture cache.
	texture_sp = ATextureCache::GetInstance()->Cache(path, new ATexture(buffer, contentWidth, contentHeight, width, height, GL_RGBA, bpp));

	// after texture is created, the buffer data will be uploaded to OpenGL, so no long needed.
	delete[] buffer;

	// This is a pointer to the loaded image data
	return texture_sp;
}
bool LTexture::loadPixelsFromFile32( std::string path )
{
    //Free texture data if needed
    freeTexture();

    //Texture loading success
    bool pixelsLoaded = false;

    //Generate and set current image ID
    ILuint imgID = 0;
    ilGenImages( 1, &imgID );
    ilBindImage( imgID );

    //Load image
    ILboolean success = ilLoadImage( path.c_str() );

    //Image loaded successfully
    if( success == IL_TRUE )
    {
        //Convert image to RGBA
        success = ilConvertImage( IL_RGBA, IL_UNSIGNED_BYTE );
        if( success == IL_TRUE )
        {
            //Initialize dimensions
            GLuint imgWidth = (GLuint)ilGetInteger( IL_IMAGE_WIDTH );
            GLuint imgHeight = (GLuint)ilGetInteger( IL_IMAGE_HEIGHT );

            //Calculate required texture dimensions
            GLuint texWidth = powerOfTwo( imgWidth );
            GLuint texHeight = powerOfTwo( imgHeight );

            //Texture is the wrong size
            if( imgWidth != texWidth || imgHeight != texHeight )
            {
                //Place image at upper left
                iluImageParameter( ILU_PLACEMENT, ILU_UPPER_LEFT );

                //Resize image
                iluEnlargeCanvas( (int)texWidth, (int)texHeight, 1 );
            }

            //Allocate memory for texture data
            GLuint size = texWidth * texHeight;
            mPixels32 = new GLuint[ size ];

            //Get image dimensions
            mImageWidth = imgWidth;
            mImageHeight = imgHeight;
            mTextureWidth = texWidth;
            mTextureHeight = texHeight;

            //Copy pixels
            memcpy( mPixels32, ilGetData(), size * 4 );
            pixelsLoaded = true;
        }

        //Delete file from memory
        ilDeleteImages( 1, &imgID );

        //Set pixel format
        mPixelFormat = GL_RGBA;
    }

    //Report error
    if( !pixelsLoaded )
    {
        printf( "Unable to load %s\n", path.c_str() );
    }

    return pixelsLoaded;
}
Example #6
0
bool CCLUDrawBase::SaveScreen2BMP(const char *pcFilename)
{
	ILuint uImgID;
	int iWidth, iHeight;
	unsigned char *pImage;
	cStr csFilename, csBaseName, csExt;
	int iExtPos;
	bool bEPSFile = false;
	bool bJPS = false;

	csBaseName = csFilename = pcFilename;

	iExtPos = ('.' < csBaseName);
	csExt = csBaseName.Last(csFilename.Len() - iExtPos, 1);
	csBaseName |= -1;

	if (csExt == "eps")
	{
		csFilename = csBaseName + ".tmp";
		bEPSFile = true;
	}
	else if (csExt == "jps")
	{
		csFilename = csBaseName + ".jpg";
		bEPSFile = true;
		bJPS = true;
	}

	iWidth = m_iSizeX; 
	iHeight =  m_iSizeY;

	ilGenImages(1, &uImgID);
	ilBindImage(uImgID);
	if (iluEnlargeCanvas(iWidth, iHeight, 1) == IL_FALSE)
	{
		ilDeleteImages(1, &uImgID);
		return false;
	}

	ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE);
	pImage = (unsigned char *) ilGetData();

	// Get Pixels
	glPixelStorei(GL_PACK_ALIGNMENT,1);
	glReadBuffer(GL_FRONT_LEFT);
	glReadPixels( 0, 0, iWidth, iHeight, GL_RGB, GL_UNSIGNED_BYTE, pImage );

	remove(csFilename.Str());

	if (bEPSFile)
	{
		if (ilSave(IL_JPG, (ILstring) csFilename.Str()) == IL_FALSE)
		{
			ilDeleteImages(1, &uImgID);
			return false;
		}
	}
	else
	{
		if (ilSaveImage((ILstring) csFilename.Str()) == IL_FALSE)
		{
			ilDeleteImages(1, &uImgID);
			return false;
		}
	}

	ilDeleteImages(1, &uImgID);

	if (bEPSFile)
	{
		csBaseName += ".eps";

		if (!ConvertJPEGtoPS(csFilename.Str(), csBaseName.Str()))
			return false;

		if (!bJPS)
			remove(csFilename.Str());
	}


	return true;
}
//Load----------------------------------------------------------------------
bool TextureItem::Load( GLuint minFilter, GLuint maxFilter, bool forceMipmap, bool resizeIfNeeded )
{
    /** NOTE: This is a test of using an archive file.  This will need to
        be modified to allow direct file access, or archived file access.
    */
    ArchiveFile* file = ArchiveManager::GetSingleton().CreateArchiveFile( mImageFileName );
    if ( file )
    {
        UInt32 fileSize = file->Length();
        unsigned char* buf = new unsigned char [ fileSize ];
        if ( !buf )
        {
            delete file;
            return false;
        }
        file->Read( buf, fileSize );

        // Load the texture:

        //****
        ilInit();
        iluInit();

        // Make sure the DevIL version is valid:
        if ( ilGetInteger( IL_VERSION_NUM ) < IL_VERSION || iluGetInteger( ILU_VERSION_NUM ) < ILU_VERSION )
        {
            // Invalid version...
            delete file;
            delete buf;
            return false;
        }


        // Get the decompressed data
        ILuint imageID;
        ilGenImages( 1, &imageID );
        ilBindImage( imageID );
        //if ( ilLoadImage( const_cast< char* >( mImageFileName.c_str() ) ) )
        if ( ilLoadL( IL_TYPE_UNKNOWN, buf, fileSize ) )
        {
            // Convert the image to unsigned bytes:
            ilConvertImage( IL_RGBA, IL_UNSIGNED_BYTE );

            // Generate the GL texture
            glGenTextures( 1, &mTextureID );
            glBindTexture( GL_TEXTURE_2D, mTextureID );
            mWidth  = ilGetInteger( IL_IMAGE_WIDTH );
            mHeight = ilGetInteger( IL_IMAGE_HEIGHT );
            mOriginalWidth  = mWidth;
            mOriginalHeight = mHeight;

            // OpenGL will work better with textures that have dimensions
            // that are a power of 2.  If doing a scrolling tile map, then
            // this is pretty much a necessity.  However, there are times
            // when using a mipmap instead is perfectly fine (ie, when NOT
            // doing tiles, or in cases where we might be running out of
            // video memory...
            if ( resizeIfNeeded && !forceMipmap )
            {
                UInt32 newWidth = mWidth, newHeight = mHeight;
                if ( !Math::IsPowerOf2( mWidth ) )
                {
                    // Find the next power of 2:
                    newWidth = Math::FindNextPowerOf2( mWidth );
                }

                if ( !Math::IsPowerOf2( mHeight ) )
                {
                    // Find the next power of 2:
                    newHeight = Math::FindNextPowerOf2( mHeight );
                }

                if ( newWidth != mWidth || newHeight != mHeight )
                {
                    // Resize the canvas:
                    ilClearColor( 0, 0, 0, 0 );
                    iluImageParameter( ILU_PLACEMENT, ILU_UPPER_LEFT );
                    iluEnlargeCanvas( newWidth, newHeight, ilGetInteger( IL_IMAGE_DEPTH ) );
                    mWidth  = ilGetInteger( IL_IMAGE_WIDTH );
                    mHeight = ilGetInteger( IL_IMAGE_HEIGHT );
                }
            }

            // If forcing mipmap generation, or if the size is not a power of 2,
            // generate as mipmaps
            if ( forceMipmap || !Math::IsPowerOf2( mWidth ) || !Math::IsPowerOf2( mHeight ) )
            {
                gluBuild2DMipmaps( GL_TEXTURE_2D,
                                   ilGetInteger( IL_IMAGE_BPP ),
                                   mWidth,
                                   mHeight,
                                   ilGetInteger( IL_IMAGE_FORMAT ),
                                   GL_UNSIGNED_BYTE,
                                   ilGetData() );
            }
            else
            {
                glTexImage2D(   GL_TEXTURE_2D,
                                0,
                                ilGetInteger( IL_IMAGE_BPP ),
                                mWidth,
                                mHeight,
                                0,
                                ilGetInteger( IL_IMAGE_FORMAT ),
                                GL_UNSIGNED_BYTE,
                                ilGetData() );
            }

            // Set the minification and magnification filters
            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter );
            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, maxFilter );
            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
            glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );

            mIsLoaded = true;
        }
        else
        {
            ILenum error;
            error = ilGetError();
            //std::string errString = iluErrorString( error );
        }

        ilDeleteImages( 1, &imageID );

        //***

        // Free memory:
        delete buf;
        delete file;
    }
    else
        return false;

    return true;
}
      bool Texture::CacheIn()
      {
         fbyte *im;
         if (Bad())
         {
            return false;
         }
         if (!IsCachedIn())
         {
            ILuint image_id;
            ILint format;
            
            ilGenImages(1, &image_id);
            ilBindImage(image_id);

            if(!ilLoadImage((ILstring)m_impl->m_filename.c_str()))
            {
               ilDeleteImages(1, &image_id);
               m_impl->m_bad = true;
               cerr << "Failed to load texture file " << m_impl->m_filename << endl;
               return false;
            }

            format=ilGetInteger(IL_DXTC_DATA_FORMAT);
            switch(format)
            {
            case IL_DXT_NO_COMP:
               break;
            case IL_DXT1:
               m_impl->m_dxt_format = TextureImpl::e_dxt1;
               break;
            case IL_DXT2:
               m_impl->m_dxt_format = TextureImpl::e_dxt2;
               break;
            case IL_DXT3:
               m_impl->m_dxt_format = TextureImpl::e_dxt3;
               break;
            case IL_DXT4:
               m_impl->m_dxt_format = TextureImpl::e_dxt4;
               break;
            case IL_DXT5:
               m_impl->m_dxt_format = TextureImpl::e_dxt5;
               break;
            }
            if(m_impl->m_dxt_format!=TextureImpl::e_dxt_none)
            {
               m_impl->m_width=ilGetInteger(IL_IMAGE_WIDTH);
               m_impl->m_height=ilGetInteger(IL_IMAGE_HEIGHT);
               m_impl->m_widthP2 = m_impl->m_width;
               m_impl->m_heightP2 = m_impl->m_height;
               m_impl->m_type = Texture::TYPE_RGBA;
               ILint s;
               char *data;
               s = ilGetDXTCData(NULL,0,format);
               m_impl->m_dxt_size = s;
               im = new fbyte[s];
               ilGetDXTCData(im,s,format);
               BindTextureToOpenGL(m_impl, im);
               delete [] im;

            }
            else
            {
               format=ilGetInteger(IL_IMAGE_FORMAT);

               if(format == IL_RGBA || format == IL_BGRA || format == IL_LUMINANCE_ALPHA || m_impl->m_autoGenAlphaMask)
               {
                  ilConvertImage(IL_RGBA,IL_UNSIGNED_BYTE);
                  m_impl->m_type = Texture::TYPE_RGBA;
               }
               else
               {
                  ilConvertImage(IL_RGB,IL_UNSIGNED_BYTE);
                  m_impl->m_type = Texture::TYPE_RGB;
               }

               m_impl->m_width=ilGetInteger(IL_IMAGE_WIDTH);
               m_impl->m_height=ilGetInteger(IL_IMAGE_HEIGHT);
               m_impl->m_widthP2 = m_impl->m_width;
               m_impl->m_heightP2 = m_impl->m_height;

               if((m_impl->m_width  & (m_impl->m_width  - 1)) != 0 ||
                  (m_impl->m_height & (m_impl->m_height - 1)) != 0)
               {
                  for(fdword i=2;i<=c_max_texture_size_power;i++)
                  {
                     if((m_impl->m_width<<1) > (1UL<<i))
                     {
                        m_impl->m_widthP2 = (1UL<<i);
                     }
                     if((m_impl->m_height<<1) > (1UL<<i))
                     {
                        m_impl->m_heightP2 = (1UL<<i);
                     }
                  }

				  cerr << m_impl->m_filename << " has invalid texture size: " << 
                     m_impl->m_width << "x" << m_impl->m_height << 
                     "  resizing to " <<
                     m_impl->m_widthP2 << "x" << m_impl->m_heightP2 << endl;

                  cerr << "   Wasted space due to texture resize: " << 
                     (((m_impl->m_widthP2 * m_impl->m_heightP2) - 
                       (m_impl->m_width * m_impl->m_height)) / 
                       float(m_impl->m_widthP2 * m_impl->m_heightP2)) * 100.0f << 
                       "%" << endl;

                  iluImageParameter(ILU_PLACEMENT, ILU_UPPER_LEFT);
                  ilClearColour(1.0f,0.2f,0.8f,1.0f);

                  if(!iluEnlargeCanvas(m_impl->m_widthP2, m_impl->m_heightP2, ilGetInteger(IL_IMAGE_DEPTH)))
                  {
                     ilDeleteImages(1, &image_id);
                     m_impl->m_bad = true;
                     cerr << "Resize of texture canvas failed" << endl;
                     return false;
                  }
               }

               im = ilGetData();
               if(m_impl->m_autoGenAlphaMask)
               {
                  Colour c;
                  fdword i,j;
                  for(j=0;j<m_impl->m_height;j++)
                  {
                     for(i=0;i<m_impl->m_width;i++)
                     {
                        c.FromInteger(((fdword *)im)[j*m_impl->m_widthP2+i],
                           c_rgba_red_mask, c_rgba_red_shift,
                           c_rgba_green_mask, c_rgba_green_shift,
                           c_rgba_blue_mask, c_rgba_blue_shift,
                           c_rgba_alpha_mask, c_rgba_alpha_shift);
                        GF1::Colour cd(c - m_impl->m_autoGenAlphaMaskColour);
                        if(m_impl->m_autoGenAlphaMaskFade && m_impl->m_autoGenAlphaMaskTolerance > 0)
                        {
                           c.a = cd.Length() / m_impl->m_autoGenAlphaMaskTolerance;
                        }
                        else
                        {
                           if(cd.LengthSquared() <= m_impl->m_autoGenAlphaMaskTolerance * m_impl->m_autoGenAlphaMaskTolerance)
                           {
                              c.a=0.0f;
                           }
                           else
                           {
                              c.a=1.0f;
                           }
                        }
                        ((fdword *)im)[j*m_impl->m_widthP2+i] = c.ToInteger(255,0,255,8,255,16,255,24);
                     }
                  }
               }
               BindTextureToOpenGL(m_impl, im);
            }
            ilDeleteImages(1, &image_id);
         }
         return true;
      }