Example #1
0
        public static MipmapFormat GetFormatForTex(FreeImageFormat imageFormat, TexFormat texFormat)
        {
            if (imageFormat != FreeImageFormat.FIF_UNKNOWN)
            {
                return(FreeImageFormatToMipmapFormat(imageFormat));
            }

            switch (texFormat)
            {
            case TexFormat.RGBA8888:
                return(MipmapFormat.RGBA8888);

            case TexFormat.DXT5:
                return(MipmapFormat.CompressedDXT5);

            case TexFormat.DXT3:
                return(MipmapFormat.CompressedDXT3);

            case TexFormat.DXT1:
                return(MipmapFormat.CompressedDXT1);

            case TexFormat.R8:
                return(MipmapFormat.R8);

            case TexFormat.RG88:
                return(MipmapFormat.RG88);

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Example #2
0
        public FreeImage(Bitmap bitmap, ImageFormat imageFormat)
        {
            FreeImageFormat fif = ImageFormatToFIF(imageFormat);

            if (fif == FreeImageFormat.Unknown)
            {
                throw new Exception("Image format \"" + imageFormat.ToString() + "\" is not supported");
            }

            MemoryStream ms = new MemoryStream();

            bitmap.Save(ms, imageFormat);
            ms.Flush();

            byte[] buffer = new byte[((int)(ms.Length - 1)) + 1];
            ms.Position = 0;
            ms.Read(buffer, 0, (int)ms.Length);
            ms.Close();

            IntPtr dataPtr = Marshal.AllocHGlobal(buffer.Length);

            Marshal.Copy(buffer, 0, dataPtr, buffer.Length);

            m_MemPtr = FreeImageApi.OpenMemory(dataPtr, buffer.Length);
            m_Handle = FreeImageApi.LoadFromMemory(fif, m_MemPtr, 0);
        }
Example #3
0
        public static ImageFormat ConvertFIFFormat(FreeImageFormat format)
        {
            switch (format)
            {
            case FreeImageFormat.FIF_BMP:
                return(ImageFormat.Bmp);

            case FreeImageFormat.FIF_ICO:
                return(ImageFormat.Icon);

            case FreeImageFormat.FIF_JPEG:
            case FreeImageFormat.FIF_JNG:
            case FreeImageFormat.FIF_J2K:
            case FreeImageFormat.FIF_JP2:
                return(ImageFormat.Jpeg);

            case FreeImageFormat.FIF_PNG:
                return(ImageFormat.Png);

            case FreeImageFormat.FIF_TIFF:
                return(ImageFormat.Tiff);

            case FreeImageFormat.FIF_GIF:
                return(ImageFormat.Gif);

            default:
                return(null);
            }
        }
Example #4
0
        public bool Save(string filename, FreeImageFormat type)
        {
            if (File.Exists(filename))
            {
                File.Delete(filename);
            }

            FreeImageApi.SetPluginEnabled(type, true);

            return(FreeImageApi.Save(type, m_Handle, filename, 0));
        }
Example #5
0
        public FreeImage(string filename)
        {
            FreeImageFormat fif = FreeImageApi.GetFIFFromFilename(filename);

            if (fif == FreeImageFormat.Unknown)
            {
                throw new Exception("Unknown file format");
            }

            m_Handle = FreeImageApi.Load(fif, filename, 0);
            m_MemPtr = IntPtr.Zero;
        }
Example #6
0
        public bool Save(string filename)
        {
            if (File.Exists(filename))
            {
                File.Delete(filename);
            }

            FreeImageFormat fif = FreeImageApi.GetFIFFromFilename(filename);

            FreeImageApi.SetPluginEnabled(fif, true);

            return(FreeImageApi.Save(fif, m_Handle, filename, 0));
        }
Example #7
0
        public static string GetExtension(FreeImageFormat format)
        {
            var str = format.ToString().Split('_').Last();

            if (str == null)
            {
                return(string.Empty);
            }

            if (format == FreeImageFormat.FIF_JPEG)
            {
                str = str.Replace("JPEG", "JPG");
            }

            return($".{str.ToLower()}");
        }
Example #8
0
        public void DecompileAndSave(string path, bool overwrite)
        {
            if (!overwrite && File.Exists(path + Helper.GetExtension(
                                              ImageFormat == FreeImageFormat.FIF_UNKNOWN ? FreeImageFormat.FIF_PNG : ImageFormat)))
            {
                return;
            }

            var bytes = Decompile();

            if (ImageFormat == FreeImageFormat.FIF_UNKNOWN)
            {
                ImageFormat = FreeImageFormat.FIF_PNG;
            }

            File.WriteAllBytes(path + Helper.GetExtension(ImageFormat), bytes);
        }
Example #9
0
		public bool Save(string filename, FreeImageFormat type)
		{
			if (File.Exists(filename))
				File.Delete(filename);

			FreeImageApi.SetPluginEnabled(type, true);

			return FreeImageApi.Save(type, m_Handle, filename, 0);
		}
Example #10
0
        private static MipmapFormat FreeImageFormatToMipmapFormat(FreeImageFormat freeImageFormat)
        {
            switch (freeImageFormat)
            {
            case FreeImageFormat.FIF_UNKNOWN:
                throw new Exception($"Can't convert '{freeImageFormat}' to '{typeof(MipmapFormat)}'");

            case FreeImageFormat.FIF_BMP:
                return(MipmapFormat.ImageBMP);

            case FreeImageFormat.FIF_ICO:
                return(MipmapFormat.ImageICO);

            case FreeImageFormat.FIF_JPEG:
                return(MipmapFormat.ImageJPEG);

            case FreeImageFormat.FIF_JNG:
                return(MipmapFormat.ImageJNG);

            case FreeImageFormat.FIF_KOALA:
                return(MipmapFormat.ImageKOALA);

            case FreeImageFormat.FIF_LBM:
                return(MipmapFormat.ImageLBM);

            case FreeImageFormat.FIF_MNG:
                return(MipmapFormat.ImageMNG);

            case FreeImageFormat.FIF_PBM:
                return(MipmapFormat.ImagePBM);

            case FreeImageFormat.FIF_PBMRAW:
                return(MipmapFormat.ImagePBMRAW);

            case FreeImageFormat.FIF_PCD:
                return(MipmapFormat.ImagePCD);

            case FreeImageFormat.FIF_PCX:
                return(MipmapFormat.ImagePCX);

            case FreeImageFormat.FIF_PGM:
                return(MipmapFormat.ImagePGM);

            case FreeImageFormat.FIF_PGMRAW:
                return(MipmapFormat.ImagePGMRAW);

            case FreeImageFormat.FIF_PNG:
                return(MipmapFormat.ImagePNG);

            case FreeImageFormat.FIF_PPM:
                return(MipmapFormat.ImagePPM);

            case FreeImageFormat.FIF_PPMRAW:
                return(MipmapFormat.ImagePPMRAW);

            case FreeImageFormat.FIF_RAS:
                return(MipmapFormat.ImageRAS);

            case FreeImageFormat.FIF_TARGA:
                return(MipmapFormat.ImageTARGA);

            case FreeImageFormat.FIF_TIFF:
                return(MipmapFormat.ImageTIFF);

            case FreeImageFormat.FIF_WBMP:
                return(MipmapFormat.ImageWBMP);

            case FreeImageFormat.FIF_PSD:
                return(MipmapFormat.ImagePSD);

            case FreeImageFormat.FIF_CUT:
                return(MipmapFormat.ImageCUT);

            case FreeImageFormat.FIF_XBM:
                return(MipmapFormat.ImageXBM);

            case FreeImageFormat.FIF_XPM:
                return(MipmapFormat.ImageXPM);

            case FreeImageFormat.FIF_DDS:
                return(MipmapFormat.ImageDDS);

            case FreeImageFormat.FIF_GIF:
                return(MipmapFormat.ImageGIF);

            case FreeImageFormat.FIF_HDR:
                return(MipmapFormat.ImageHDR);

            case FreeImageFormat.FIF_FAXG3:
                return(MipmapFormat.ImageFAXG3);

            case FreeImageFormat.FIF_SGI:
                return(MipmapFormat.ImageSGI);

            case FreeImageFormat.FIF_EXR:
                return(MipmapFormat.ImageEXR);

            case FreeImageFormat.FIF_J2K:
                return(MipmapFormat.ImageJ2K);

            case FreeImageFormat.FIF_JP2:
                return(MipmapFormat.ImageJP2);

            case FreeImageFormat.FIF_PFM:
                return(MipmapFormat.ImagePFM);

            case FreeImageFormat.FIF_PICT:
                return(MipmapFormat.ImagePICT);

            case FreeImageFormat.FIF_RAW:
                return(MipmapFormat.ImageRAW);

            default:
                throw new ArgumentOutOfRangeException(nameof(freeImageFormat), freeImageFormat, null);
            }
        }
Example #11
0
 public Tex()
 {
     Format      = TexFormat.ARGB8888;
     ImageFormat = FreeImageFormat.FIF_UNKNOWN;
     Mipmaps     = new List <TexMipmap>();
 }
Example #12
0
        public static bool IsValid(this FreeImageFormat format)
        {
            var formatId = (int)format;

            return(formatId >= -1 && formatId <= 34);
        }