Beispiel #1
0
            //Return a boolean, test if the file should be excluded
            public bool IsFileExcluded(string sFilePath, FolderProcessingParams cfg)
            {
                var extension = Path.GetExtension(sFilePath);

                if (!cfg.ProcessMBMs && extension == ".mbm")
                {
                    return(true);
                }
                if (!cfg.ProcessTGAs && extension == ".tga")
                {
                    return(true);
                }
                if (!cfg.ProcessPNGs && extension == ".png")
                {
                    return(true);
                }

                var b = false;

                //No idea what this does
                for (var i = 0; i <= excludedList.Count - 1; i++)
                {
                    if (sFilePath.Contains(excludedList[i]))
                    {
                        i = excludedList.Count - 1;
                        b = true;
                    }
                }
                return(b);
            }
Beispiel #2
0
        //a custom function to call ShowDialog(), so parameters can be updated before the window is closed
        public DialogResult CustomShowDialog(string sPath, FolderProcessingParams CFG)
        {
            if (ShowDialog() == DialogResult.OK)
            {
                //(assume CFG is already instantiated)
                //Format
                CFG.Compressed  = RB_format_compressed.Checked;
                CFG.ProcessMBMs = CB_format_incMBM.Checked;
                CFG.ProcessTGAs = CB_format_incTGA.Checked;
                CFG.ProcessPNGs = CB_format_incPNG.Checked;
                //normals
                CFG.NormalsManagement = CB_normal_ConvSelect.SelectedIndex;
                //mipmaps
                CFG.GenerateMipmaps = CB_mipmap_Generate.Checked;
                //resize
                if (CB_resize_MinResolution.Checked)
                {
                    CFG.MinRes_Resize_Width  = Convert.ToInt32(NUD_resize_MinWidth.Value);
                    CFG.MinRes_Resize_Height = Convert.ToInt32(NUD_resize_MinHeight.Value);
                }
                else
                {
                    CFG.MinRes_Resize_Width  = 1;
                    CFG.MinRes_Resize_Height = 1;
                }
                switch (CB_resize_Ratio.SelectedIndex)
                {
                case 0:
                    CFG.ResizeRatio = 1;
                    break;

                case 1:
                    CFG.ResizeRatio = 0.75;
                    break;

                case 2:
                    CFG.ResizeRatio = 0.5;
                    break;

                case 3:
                    CFG.ResizeRatio = 0.25;
                    break;

                default:
                    CFG.ResizeRatio = 1;
                    break;
                }
                //misc
                CFG.MinRes_Process_Width  = Convert.ToInt32(NUD_misc_MinWidth.Value);
                CFG.MinRes_Process_Height = Convert.ToInt32(NUD_misc_MinHeight.Value);
                CFG.DeleteFilesOnSuccess  = RB_misc_DeleteFiles.Checked;
                CFG.BackupFile            = RB_misc_KeepBackups.Checked;
                CFG.IgnoreExceptions      = CB_misc_IgnoreExceptions.Checked;
                return(DialogResult.OK);
            }
            else
            {
                return(DialogResult.Cancel);
            }
        }
Beispiel #3
0
        //resetting the controls to something accurate
        private void ResetWindow()
        {
            //create a new cfg to reset automatic parameters
            var folderCFG = new FolderProcessingParams();

            //Format
            RB_format_compressed.Checked = folderCFG.Compressed;
            CB_format_incMBM.Checked     = folderCFG.ProcessMBMs;
            CB_format_incTGA.Checked     = folderCFG.ProcessTGAs;
            CB_format_incPNG.Checked     = folderCFG.ProcessPNGs;
            //normals
            CB_normal_ConvSelect.SelectedIndex = folderCFG.NormalsManagement;
            //mipmaps
            CB_mipmap_Generate.Checked = folderCFG.GenerateMipmaps;
            //resize
            CB_resize_Ratio.SelectedIndex   = 0;
            CB_resize_MinResolution.Checked = true;
            NUD_resize_MinWidth.Value       = folderCFG.MinRes_Resize_Width;
            NUD_resize_MinHeight.Value      = folderCFG.MinRes_Resize_Height;
            //misc
            NUD_misc_MinWidth.Value          = folderCFG.MinRes_Process_Height;
            NUD_misc_MinHeight.Value         = folderCFG.MinRes_Process_Width;
            RB_misc_DeleteFiles.Checked      = folderCFG.DeleteFilesOnSuccess;
            RB_misc_KeepBackups.Checked      = folderCFG.BackupFile;
            CB_misc_IgnoreExceptions.Checked = folderCFG.IgnoreExceptions;
        }
Beispiel #4
0
            //Return a boolean, test if the file should be excluded
            public bool IsFileExcluded(string sFilePath, FolderProcessingParams cfg)
            {
                var extension = Path.GetExtension(sFilePath);

                if (!cfg.ProcessMBMs && extension == ".mbm")
                {
                    return(true);
                }
                if (!cfg.ProcessTGAs && extension == ".tga")
                {
                    return(true);
                }
                if (!cfg.ProcessPNGs && extension == ".png")
                {
                    return(true);
                }

                var b = false;

                //No idea what this does
                for (var i = 0; i <= excludedList.Count - 1; i++)
                {
                    if (sFilePath.Contains(excludedList[i]))
                    {
                        i = excludedList.Count - 1;
                        b = true;
                        // performance optimization with long exclude lists:
                        // after first match dont check rest of exclusions
                        return(b);
                    }
                }
                return(b);
            }
Beispiel #5
0
        //Folder/export all
        private void ExportAllToDDSToolStripMenuItem_Click(Object sender, EventArgs e)
        {
            var folderCFG = new FolderProcessingParams();
            var dlgFolder = new FolderDialog();

            if (dlgFolder.CustomShowDialog(loadedFolder, folderCFG) == DialogResult.OK)
            {
                PB_main.Visible     = true;
                lbl_PBInfos.Visible = true;
                lbl_PBInfos.Text    = "";
                PB_main.Value       = 0;
                FolderLoader.ProcessFileLists(loadedFolder, folderCFG);
                PB_main.Visible     = false;
                lbl_PBInfos.Visible = false;
            }
        }
Beispiel #6
0
        //Convert a mbm file to dds
        public static void ConvertMBMtoDDS(ConversionParameters convParams, FolderProcessingParams cfg)
        {
            //get a new filepath with a dds extension
            var fpNew = Path.ChangeExtension(convParams.FilePath, ".dds");

            //open a new mbm file
            var mbmTemp = new MBMLoader.MBMFile(convParams.FilePath);

            //resize ratio
            var dRatio = cfg.ResizeRatio;

            if (convParams.ResizeSetting == ResizeSetting.DontAllowResize)
            {
                dRatio = 1;
            }

            //mipmaps level
            var mipmapLevel = 0;

            if (convParams.MipmapSetting == MipmapSetting.DontGenerate)
            {
                mipmapLevel = 1;
            }

            //output format
            var form = default(Format);

            switch (convParams.OutputFormat)
            {
            case OutputFormat.AutoUncompressed:
                if (mbmTemp.IsNormal)
                {
                    form = Format.A8R8G8B8;
                }
                else if (mbmTemp.ColorDepth == 24)
                {
                    form = Format.R8G8B8;
                }
                else
                {
                    form = Format.A8R8G8B8;
                }
                break;

            case OutputFormat.AutoCompressed:
                form = mbmTemp.ColorDepth == 24 ? Format.Dxt1 : Format.Dxt5;
                break;

            case OutputFormat.ForceArgb8:
                form = Format.A8R8G8B8;
                break;

            case OutputFormat.ForceRgb8:
                form = Format.R8G8B8;
                break;

            case OutputFormat.ForceDXT5:
                form = Format.Dxt5;
                break;

            case OutputFormat.ForceDXT1:
                form = Format.Dxt1;
                break;
            }

            //force normal, or automatic detection
            var bNormal = false;

            switch (convParams.NormalMapConversion)
            {
            case NormalMapConversion.Automatic:
                bNormal = mbmTemp.IsNormal;
                break;

            case NormalMapConversion.ForceNormal:
                bNormal = true;
                break;
            }

            //conversion
            using (var gs = new MemoryStream())
            {
                mbmTemp.AsBitmap().Save(gs, ImageFormat.Bmp);

                MainForm.Log_WriteLine("LOG : Converting " + convParams.FilePath + " to " + fpNew);
                MainForm.Log_WriteLine("    Format : " + form + ", normalmap : " + bNormal + ", res: " + (mbmTemp.Width * dRatio) + "x" + (mbmTemp.Height * dRatio));

                if ((((mbmTemp.Width < cfg.MinRes_Resize_Width) | (mbmTemp.Height < cfg.MinRes_Resize_Height)) & (Math.Abs(dRatio - 1) > 0.0001f)))
                {
                    MainForm.Log_WriteLine("LOG : " + convParams.FilePath.Split('.').Last() + ", resolution is too low to be resized.");
                    dRatio = 1;
                }
                gs.Position = 0;

                using (var t = TextureLoader.FromStream(dev, gs, (int)(mbmTemp.Width * dRatio), (int)(mbmTemp.Height * dRatio), mipmapLevel, Usage.None, form, Pool.SystemMemory, Filter.Triangle | Filter.Dither, Filter.Triangle | Filter.Dither, 0))
                {
                    TextureLoader.Save(fpNew, ImageFileFormat.Dds, t);
                }
            }

            //set flag for dxt5nm
            if (bNormal)
            {
                MarkAsNormal(fpNew);
            }

            //flush textures
            mbmTemp.Flush();

            var ddsifiedFile = convParams.FilePath + ".ddsified";

            //delete file after successful conversion
            if (File.Exists(fpNew))
            {
                if (cfg.BackupFile)
                {
                    if (File.Exists(ddsifiedFile))
                    {
                        File.Delete(ddsifiedFile);
                    }

                    File.Move(convParams.FilePath, convParams.FilePath + ".ddsified");
                }
                else if (cfg.DeleteFilesOnSuccess)
                {
                    File.Delete(convParams.FilePath);
                }
            }
        }
Beispiel #7
0
        //convert a non-mbm file to dds

        public static void ConvertFileToDDS(ConversionParameters convParams, FolderProcessingParams cfg)
        {
            var sw = Stopwatch.StartNew();

            //test: to avoid memory leak, reset the device before every conversion... As this program can't compile on for x64 OSs, large texture hit memory lmit quite fast...
            //there's a known bug with DirectX9 and his way to load TGA files, image buffer is kept in memory even when the texture is disposed. And, of course, .NET's GarbageCollector is not useful AT ALL here...
            ResetDevice();
            /////
            //normals. Since the AssumeNormalMap() function is able to determine if a file failed to load, this function should be called before anything else
            var bNormal   = false;
            var bLoadFail = false;

            switch (convParams.NormalMapConversion)
            {
            case NormalMapConversion.Automatic:
                bNormal = AssumeNormalMap(convParams.FilePath, out bLoadFail);
                break;

            case NormalMapConversion.ForceNormal:
                bNormal = true;
                break;
            }

            //skip the file if it failed to load
            if (bLoadFail)
            {
                return;
            }

            //get a new filepath for our newly created dds
            var fpNew = Path.ChangeExtension(convParams.FilePath, ".dds");
            //retrive infos from the original file
            var iInfos = TextureLoader.ImageInformationFromFile(convParams.FilePath);

            //resize ratio
            var dRatio = cfg.ResizeRatio;

            if (convParams.ResizeSetting == ResizeSetting.DontAllowResize)
            {
                dRatio = 1;
            }

            //Mipmaps level
            var mipmapLevel = 0;

            if (convParams.MipmapSetting == MipmapSetting.DontGenerate)
            {
                mipmapLevel = 1;
            }

            //Output format
            var form = default(Format);

            switch (convParams.OutputFormat)
            {
            case OutputFormat.AutoUncompressed:
                if (bNormal)
                {
                    form = Format.A8R8G8B8;
                }
                else
                {
                    form = Is32BPP(iInfos) ? Format.A8R8G8B8 : Format.R8G8B8;
                }
                break;

            case OutputFormat.AutoCompressed:
                if (bNormal)
                {
                    form = Format.Dxt5;
                }
                else
                {
                    form = Is32BPP(iInfos) ? Format.Dxt5 : Format.Dxt1;
                }
                break;

            case OutputFormat.ForceArgb8:
                form = Format.A8R8G8B8;
                break;

            case OutputFormat.ForceRgb8:
                form = Format.R8G8B8;
                break;

            case OutputFormat.ForceDXT5:
                form = Format.Dxt5;
                break;

            case OutputFormat.ForceDXT1:
                form = Format.Dxt1;
                break;
            }

            //info for log
            MainForm.Log_WriteLine("LOG : Converting " + convParams.FilePath + " to " + fpNew);

            //keep small images uncompressed. This is independent from any parameters, the value of 64 is hard-coded
            if (((iInfos.Width < MinHeightForCompressed) | (iInfos.Height < MinHeightForCompressed)))
            {
                if (((form == Format.Dxt1) | (form == Format.Dxt5)))
                {
                    MainForm.Log_WriteLine("LOG : Resolution is considered too low for DXT compression. Switching to uncompressed format for better quality.");
                }
                form        = Format.A8R8G8B8;
                mipmapLevel = 1;
            }


            //skip file if the resolution is not correct
            if (((iInfos.Width < cfg.MinRes_Process_Width) | (iInfos.Height < cfg.MinRes_Process_Width)))
            {
                MainForm.Log_WriteLine("LOG : Skipping " + convParams.FilePath + ", resolution is too low.");
                FolderLoader.FileSkipCount += 1;
                return;
            }

            //check if the file is large enough to be resized
            if ((((iInfos.Width < cfg.MinRes_Resize_Width) | (iInfos.Height < cfg.MinRes_Resize_Height)) & (Math.Abs(dRatio - 1) > 0.0001f)))
            {
                MainForm.Log_WriteLine("LOG : " + convParams.FilePath.Split('.').Last() + ", resolution is too low to be resized.");
                dRatio = 1;
            }

            //corrected width and height, we want them to be multiple of 4
            var iCorWidth  = iInfos.Width;
            var iCorHeight = iInfos.Height;

            if (((iCorWidth % 4) != 0))
            {
                iCorWidth += (4 - (iCorWidth % 4));
            }
            if (((iCorHeight % 4) != 0))
            {
                iCorHeight += (4 - (iCorHeight % 4));
            }

            //bmp format for flipping
            Texture texture;

            if (bppFormats24.Contains(iInfos.Format))
            {
                texture = TextureLoader.FromFile(dev, convParams.FilePath, iCorWidth, iCorHeight, 1, Usage.None, Format.R8G8B8, Pool.SystemMemory, Filter.None, Filter.None, 0);
                //t = TextureLoader.FromFile(dev, convParams.FilePath, iCorWidth, iCorHeight, 1, Usage.None, form, Pool.SystemMemory, Filter.None, Filter.None, 0)
            }
            else if (bppFormats32.Contains(iInfos.Format))
            {
                texture = TextureLoader.FromFile(dev, convParams.FilePath, iCorWidth, iCorHeight, 1, Usage.None, Format.A8B8G8R8, Pool.SystemMemory, Filter.None, Filter.None, 0);
            }
            else
            {
                MainForm.Log_WriteLine("ERR : Unknown file format " + iInfos.Format + ", skipping conversion for " + convParams.FilePath);
                FolderLoader.FileSkipCount += 1;
                return;
            }

            //info for log
            MainForm.Log_WriteLine("    Format : " + form + ", normalmap : " + bNormal + ", res: " + (iCorWidth * dRatio) + "x" + (iCorHeight * dRatio));

            //the output is saved in a graphicStream, but a memorystream could work just as well.
            var gs = TextureLoader.SaveToStream(ImageFileFormat.Bmp, texture);

            texture.Dispose();

            //flip
            FlipImage(gs);

            //switch to tga format if swizzling
            if (bNormal)
            {
                var sw2 = Stopwatch.StartNew();
                texture.Dispose();
                texture = TextureLoader.FromStream(dev, gs);
                gs.Close();
                gs.Dispose();
                gs = TextureLoader.SaveToStream(ImageFileFormat.Tga, texture);
                texture.Dispose();
                SwizzleImage(gs, iCorWidth, iCorHeight, Is32BPP(iInfos));
                sw.Stop();
                MainForm.Log_WriteLine(String.Format("SwizzleImage took {0}ms", sw2.Elapsed.TotalMilliseconds));
            }

            //another attempt to flush memory: the program tend to crash if too much large textures are converted
            //though, if some smaller textures are converted in between, memory is flushed correctly...
            dev.Reset(pParameters);

            //saving the texture
            texture = TextureLoader.FromStream(dev, gs, (int)(iCorWidth * dRatio), (int)(iCorHeight * dRatio), mipmapLevel, Usage.None, form, Pool.SystemMemory, Filter.Triangle | Filter.DitherDiffusion, Filter.Triangle | Filter.DitherDiffusion, 0);
            TextureLoader.Save(fpNew, ImageFileFormat.Dds, texture);
            //delete unused stuff
            texture.Dispose();
            gs.Close();
            gs.Dispose();

            //set flag for normals
            if (bNormal)
            {
                MarkAsNormal(fpNew);
            }

            var ddsifiedFile = convParams.FilePath + ".ddsified";

            //remove/Backup original file after successful conversion
            if (File.Exists(fpNew))
            {
                if (cfg.BackupFile)
                {
                    if (File.Exists(ddsifiedFile))
                    {
                        File.Delete(ddsifiedFile);
                    }

                    File.Move(convParams.FilePath, ddsifiedFile);
                }
                else if (cfg.DeleteFilesOnSuccess)
                {
                    File.Delete(convParams.FilePath);
                }
            }
            sw.Stop();

            MainForm.Log_WriteLine(String.Format("Image conversion took {0}ms", sw.Elapsed.TotalMilliseconds));
        }
Beispiel #8
0
        //processing files lists
        public static void ProcessFileLists(string sFolderPath, FolderProcessingParams cfg)
        {
            RefreshInfo(sFolderPath, false, false);
            FileSkipCount = 0;

            var iExcludeCount = 0;
            var argHandler    = new ArgumentsHandler();
            var lConvParms    = new List <ImageManager.ConversionParameters>();

            foreach (var s in fileList)
            {
                if (!argHandler.IsFileExcluded(s, cfg))
                {
                    lConvParms.Add(argHandler.GetConversionParameters(s, cfg));
                }
                else
                {
                    iExcludeCount += 1;
                }
            }

            var iStep = 0;

            MainForm.Log_WriteLine("-----");
            MainForm.Log_WriteLine("Starting conversion of " + fileList.Count + " files.");
            MainForm.Log_WriteLine("    MBM count : " + argHandler.Count_MBM + ".");
            MainForm.Log_WriteLine("    TGA count : " + argHandler.Count_TGA + ".");
            MainForm.Log_WriteLine("    PNG count : " + argHandler.Count_PNG + ".");
            MainForm.Log_WriteLine(iExcludeCount + " files excluded, " + argHandler.Count_NoMipmaps + " files without mipmaps. " + (argHandler.Count_ForceNormal + argHandler.Count_ForceNotNormal) + " files will skip normal detection." + argHandler.Count_NoResize + " files will not be resized.");
            MainForm.Log_WriteLine("-----");

            var sw = Stopwatch.StartNew();

            //processing
            foreach (var c in lConvParms)
            {
                if (c.FileType == ImageManager.FileType.MBM)
                {
                    ImageManager.ConvertMBMtoDDS(c, cfg);
                }
                else
                {
                    ImageManager.ConvertFileToDDS(c, cfg);
                }

                iStep += 1;

                MainForm.ReportProgress(Convert.ToInt32((iStep / lConvParms.Count) * 100), "Processing " + Path.GetFileName(c.FilePath) + ", file " + iStep + "\\" + lConvParms.Count);
                MainForm.Log_WriteLine("---");
                Application.DoEvents();
            }

            sw.Stop();
            MainForm.Log_WriteLine("-----");
            MainForm.Log_WriteLine(String.Format("Conversion done! {0} files processed in {1}ms.", lConvParms.Count, sw.Elapsed.TotalMilliseconds));
            if (FileSkipCount > 0)
            {
                MainForm.Log_WriteLine(FileSkipCount + " files skipped, check log.txt for more informations.");
            }
            MainForm.Log_WriteLine("-----");
        }
Beispiel #9
0
            //return a conversion parameter for a single file, according to modsExceptions.txt
            public ImageManager.ConversionParameters GetConversionParameters(string sFilePath, FolderProcessingParams folderParams)
            {
                //resfresh counts
                var extension = Path.GetExtension(sFilePath);

                switch (extension)
                {
                case ".mbm":
                    Count_MBM += 1;
                    break;

                case ".tga":
                    Count_TGA += 1;
                    break;

                case ".png":
                    Count_PNG += 1;
                    break;
                }
                //resfresh parameters
                var cpRet = new ImageManager.ConversionParameters(sFilePath);

                if (folderParams.IgnoreExceptions)
                {
                    //normals flag
                    switch (folderParams.NormalsManagement)
                    {
                    case 0:
                        cpRet.NormalMapConversion = ImageManager.NormalMapConversion.Automatic;
                        break;

                    case 1:
                        cpRet.NormalMapConversion = ImageManager.NormalMapConversion.ForceNormal;
                        Count_ForceNormal        += 1;
                        break;

                    case 2:
                        cpRet.NormalMapConversion = ImageManager.NormalMapConversion.ForceNotNormal;
                        Count_ForceNotNormal     += 1;
                        break;
                    }
                    //mipmaps flag
                    cpRet.MipmapSetting = folderParams.GenerateMipmaps ? ImageManager.MipmapSetting.Generate : ImageManager.MipmapSetting.DontGenerate;
                    cpRet.ResizeSetting = ImageManager.ResizeSetting.AllowResize;
                }
                else
                {
                    //normals flag
                    var bB = false;
                    for (var i = 0; i <= forceNormalList.Count - 1; i++)
                    {
                        if (sFilePath.Contains(forceNormalList[i]))
                        {
                            cpRet.NormalMapConversion = ImageManager.NormalMapConversion.ForceNormal;
                            Count_ForceNormal        += 1;
                            i  = forceNormalList.Count - 1;
                            bB = true;
                        }
                    }
                    if (!bB)
                    {
                        for (var i = 0; i <= forceNotNormalList.Count - 1; i++)
                        {
                            if (sFilePath.Contains(forceNotNormalList[i]))
                            {
                                cpRet.NormalMapConversion = ImageManager.NormalMapConversion.ForceNotNormal;
                                Count_ForceNotNormal     += 1;
                                i  = forceNotNormalList.Count - 1;
                                bB = true;
                            }
                        }
                    }
                    if (!bB)
                    {
                        switch (folderParams.NormalsManagement)
                        {
                        case 0:
                            cpRet.NormalMapConversion = ImageManager.NormalMapConversion.Automatic;
                            break;

                        case 1:
                            cpRet.NormalMapConversion = ImageManager.NormalMapConversion.ForceNormal;
                            Count_ForceNormal        += 1;
                            break;

                        case 2:
                            cpRet.NormalMapConversion = ImageManager.NormalMapConversion.ForceNotNormal;
                            Count_ForceNotNormal     += 1;
                            break;
                        }
                    }
                    //no mipmaps flag
                    bB = false;
                    for (var i = 0; i <= noMipmapList.Count - 1; i++)
                    {
                        if (sFilePath.Contains(noMipmapList[i]))
                        {
                            cpRet.MipmapSetting = ImageManager.MipmapSetting.DontGenerate;
                            Count_NoMipmaps    += 1;
                            i  = noMipmapList.Count - 1;
                            bB = true;
                        }
                    }
                    if (!bB)
                    {
                        if (folderParams.GenerateMipmaps)
                        {
                            cpRet.MipmapSetting = ImageManager.MipmapSetting.Generate;
                        }
                        else
                        {
                            cpRet.MipmapSetting = ImageManager.MipmapSetting.DontGenerate;
                            Count_NoMipmaps    += 1;
                        }
                    }
                    //resize flag
                    cpRet.ResizeSetting = ImageManager.ResizeSetting.AllowResize;
                    for (var i = 0; i <= noResizeList.Count - 1; i++)
                    {
                        if (sFilePath.Contains(noResizeList[i]))
                        {
                            cpRet.ResizeSetting = ImageManager.ResizeSetting.DontAllowResize;
                            Count_NoResize     += 1;
                        }
                    }
                }
                return(cpRet);
            }
        //Custom function to call ShowDialog
        public DialogResult CustomShowDialog(string sFilePath)
        {
            sLoadedFile = sFilePath;
            AutomaticDetection(sFilePath);
            if (ShowDialog() == DialogResult.OK)
            {
                var imgCFG    = new ImageManager.ConversionParameters(sFilePath);
                var folderCFG = new FolderProcessingParams();

                if (CheckBox1.Checked)
                {
                    imgCFG.MipmapSetting      = ImageManager.MipmapSetting.Generate;
                    folderCFG.GenerateMipmaps = true;
                }
                else
                {
                    imgCFG.MipmapSetting      = ImageManager.MipmapSetting.DontGenerate;
                    folderCFG.GenerateMipmaps = false;
                }

                if (CheckBox2.Checked)
                {
                    imgCFG.NormalMapConversion  = ImageManager.NormalMapConversion.ForceNormal;
                    folderCFG.NormalsManagement = 1;
                }
                else
                {
                    imgCFG.NormalMapConversion  = ImageManager.NormalMapConversion.ForceNotNormal;
                    folderCFG.NormalsManagement = 2;
                }
                switch ((Formats)ComboBox1.SelectedIndex)
                {
                case Formats.DXT1:
                    imgCFG.OutputFormat  = ImageManager.OutputFormat.ForceDXT1;
                    folderCFG.Compressed = true;
                    break;

                case Formats.DXT5:
                    imgCFG.OutputFormat  = ImageManager.OutputFormat.ForceDXT5;
                    folderCFG.Compressed = true;
                    break;

                case Formats.R8G8B8:
                    imgCFG.OutputFormat  = ImageManager.OutputFormat.ForceRgb8;
                    folderCFG.Compressed = false;
                    break;

                case Formats.A8R8G8B8:
                    imgCFG.OutputFormat  = ImageManager.OutputFormat.ForceArgb8;
                    folderCFG.Compressed = false;
                    break;
                }
                imgCFG.ResizeSetting = ImageManager.ResizeSetting.AllowResize;

                switch (ComboBox2.SelectedIndex)
                {
                case 0:
                    folderCFG.ResizeRatio = 1;
                    break;

                case 1:
                    folderCFG.ResizeRatio = 0.75;
                    break;

                case 2:
                    folderCFG.ResizeRatio = 0.5;
                    break;

                case 3:
                    folderCFG.ResizeRatio = 0.25;
                    break;

                default:
                    folderCFG.ResizeRatio = 1;
                    break;
                }
                folderCFG.DeleteFilesOnSuccess = CheckBox3.Checked;
                folderCFG.BackupFile           = false;

                if (imgCFG.FileType == ImageManager.FileType.MBM)
                {
                    ImageManager.ConvertMBMtoDDS(imgCFG, folderCFG);
                }
                else
                {
                    ImageManager.ConvertFileToDDS(imgCFG, folderCFG);
                }

                return(DialogResult.OK);
            }

            return(DialogResult.Cancel);
        }