public static GTXImporterSettings SetImporterSettings(string name, TEX_FORMAT DefaultFormat = TEX_FORMAT.UNKNOWN)
{
var importer = new GTXImporterSettings();
string ext = System.IO.Path.GetExtension(name);
ext = ext.ToLower();
switch (ext)
{
case ".dds":
case ".dds2":
importer.LoadDDS(name);
break;
default:
importer.LoadBitMap(name);
//Override the format setting. This only will do this for images not as dds or astc
if (DefaultFormat != TEX_FORMAT.UNKNOWN)
{
importer.Format = (GX2.GX2SurfaceFormat)ConvertToGx2Format(DefaultFormat);
}
break;
}
return(importer);
}
public GTXImporterSettings LoadSettings(System.Drawing.Image image, string Name)
{
var importer = new GTXImporterSettings();
importer.LoadBitMap(image, Name);
return(importer);
}
public static GTXImporterSettings SetImporterSettings(Image image, string name)
{
var importer = new GTXImporterSettings();
importer.LoadBitMap(image, name);
return(importer);
}
public void ReplaceImage(Image image, string FileName)
{
GTXImporterSettings setting = SetImporterSettings(image, FileName);
setting.MipSwizzle = Tex2Swizzle;
setting.MipCountOriginal = (int)MipCount;
GTXTextureImporter importer = new GTXTextureImporter();
importer.LoadSetting(setting);
if (importer.ShowDialog() == DialogResult.OK)
{
Cursor.Current = Cursors.WaitCursor;
if (setting.GenerateMipmaps && !setting.IsFinishedCompressing)
{
setting.DataBlockOutput.Clear();
setting.DataBlockOutput.Add(setting.GenerateMips());
}
if (setting.DataBlockOutput != null)
{
var surface = GTXSwizzle.CreateGx2Texture(setting.DataBlockOutput[0], setting);
surface.compSel = new byte[4];
surface.compSel[0] = (byte)setting.RedComp;
surface.compSel[1] = (byte)setting.GreenComp;
surface.compSel[2] = (byte)setting.BlueComp;
surface.compSel[3] = (byte)setting.alphaRef;
var tex = FromGx2Surface(surface, setting.TexName);
UpdateTex(tex);
texture.Name = Text;
IsReplaced = true;
Read(texture);
LoadOpenGLTexture();
}
else
{
MessageBox.Show("Something went wrong???");
}
}
if (IsEditorActive() && IsReplaced)
{
UpdateEditor();
}
}
public void ReplaceImage(Image image, string FileName)
{
GTXImporterSettings setting = SetImporterSettings(image, FileName);
GTXTextureImporter importer = new GTXTextureImporter();
if (Tex2Swizzle != 0)
{
setting.swizzle = Tex2Swizzle;
}
importer.LoadSetting(setting);
if (importer.ShowDialog() == DialogResult.OK)
{
Cursor.Current = Cursors.WaitCursor;
if (setting.GenerateMipmaps)
{
setting.DataBlockOutput.Clear();
setting.DataBlockOutput.Add(setting.GenerateMips());
}
if (setting.DataBlockOutput != null)
{
var surface = setting.CreateGx2Texture(setting.DataBlockOutput[0]);
var tex = FromGx2Surface(surface, setting);
if (texture == null)
{
texture = new Texture();
}
UpdateTex(tex);
texture.Name = Text;
IsEdited = true;
Read(texture);
LoadOpenGLTexture();
}
else
{
MessageBox.Show("Something went wrong???");
}
}
if (IsEditorActive())
{
UpdateEditor();
}
}
private void ImportPlaceholderTexture(byte[] data, string TextureName)
{
GTXImporterSettings setting = new GTXImporterSettings();
setting.LoadDDS(TextureName, data);
var surface = GTXSwizzle.CreateGx2Texture(setting.DataBlockOutput[0], setting);
FTEX ftex = new FTEX();
ftex.texture = new ResU.Texture();
ftex.texture = FTEX.FromGx2Surface(surface, setting.TexName);
ftex.IsEdited = true;
ftex.Read(ftex.texture);
AddNode(ftex);
ftex.LoadOpenGLTexture();
}
//We reuse GX2 data as it's the same thing
public Texture FromGx2Surface(GTX.GX2Surface surf, GTXImporterSettings settings)
{
Texture tex = new Texture();
tex.Name = settings.TexName;
tex.Path = "";
tex.AAMode = (GX2AAMode)surf.aa;
tex.Alignment = (uint)surf.alignment;
tex.ArrayLength = 1;
tex.Data = surf.data;
tex.MipData = surf.mipData;
tex.Format = (GX2SurfaceFormat)surf.format;
tex.Dim = (GX2SurfaceDim)surf.dim;
tex.Use = (GX2SurfaceUse)surf.use;
tex.TileMode = (GX2TileMode)surf.tileMode;
tex.Swizzle = surf.swizzle;
tex.Pitch = surf.pitch;
tex.Depth = surf.depth;
tex.MipCount = surf.numMips;
tex.ViewMipCount = surf.numMips;
tex.ViewSliceCount = 1;
tex.MipOffsets = new uint[13];
for (int i = 0; i < 13; i++)
{
if (i < surf.mipOffset.Length)
{
tex.MipOffsets[i] = surf.mipOffset[i];
}
}
tex.Height = surf.height;
tex.Width = surf.width;
tex.Regs = new uint[5];
tex.ArrayLength = 1;
var channels = SetChannelsByFormat((GX2SurfaceFormat)surf.format);
tex.CompSelR = channels[0];
tex.CompSelG = channels[1];
tex.CompSelB = channels[2];
tex.CompSelA = channels[3];
tex.UserData = new ResDict <UserData>();
return(tex);
}
public static GTXImporterSettings SetImporterSettings(string name)
{
var importer = new GTXImporterSettings();
string ext = System.IO.Path.GetExtension(name);
ext = ext.ToLower();
switch (ext)
{
case ".dds":
case ".dds2":
importer.LoadDDS(name);
break;
default:
importer.LoadBitMap(name);
break;
}
return(importer);
}
public void ReplaceTexture(string FileName, TEX_FORMAT DefaultFormat = TEX_FORMAT.UNKNOWN, uint MipMapCount = 0,
uint swizzlePattern = 0, TEX_FORMAT[] SupportedFormats = null, bool DisplayBc4AlphaSetting = false,
bool IsSwizzleReadOnly = false, bool IsTileModeReadOnly = false, bool IsFormatReadOnly = false, bool flipTextureY = false)
{
string ext = System.IO.Path.GetExtension(FileName);
ext = ext.ToLower();
if (ext == ".bftex")
{
texture.Import(FileName, ((BFRESGroupNode)Parent).GetResFileU());
texture.Name = Text;
IsReplaced = true;
Read(texture);
if (IsEditorActive())
{
UpdateEditor();
}
return;
}
GTXImporterSettings setting = SetImporterSettings(FileName, DefaultFormat);
setting.FlipY = flipTextureY;
setting.MipSwizzle = Tex2Swizzle;
setting.SwizzlePattern = swizzlePattern;
GTXTextureImporter importer = new GTXTextureImporter();
importer.DisplayBC4Alpha = DisplayBc4AlphaSetting;
importer.ReadOnlySwizzle = IsSwizzleReadOnly;
importer.ReadOnlyTileMode = IsSwizzleReadOnly;
importer.ReadOnlyFormat = IsFormatReadOnly;
if (MipMapCount != 0)
{
setting.MipCount = MipMapCount;
importer.OverrideMipCounter = true;
}
if (SupportedFormats != null)
{
importer.LoadSupportedFormats(SupportedFormats);
}
importer.LoadSetting(setting);
if (ext == ".dds")
{
if (setting.DataBlockOutput != null)
{
var surface = GTXSwizzle.CreateGx2Texture(setting.DataBlockOutput[0], setting);
var tex = FromGx2Surface(surface, setting.TexName);
UpdateTex(tex);
texture.Name = Text;
IsReplaced = true;
Read(texture);
LoadOpenGLTexture();
LibraryGUI.UpdateViewport();
}
}
else
{
if (importer.ShowDialog() == DialogResult.OK)
{
Cursor.Current = Cursors.WaitCursor;
UseBc4Alpha = setting.UseBc4Alpha;
if (setting.GenerateMipmaps && !setting.IsFinishedCompressing)
{
setting.DataBlockOutput.Clear();
setting.DataBlockOutput.Add(setting.GenerateMips());
}
if (setting.DataBlockOutput != null)
{
var surface = GTXSwizzle.CreateGx2Texture(setting.DataBlockOutput[0], setting);
var tex = FromGx2Surface(surface, setting.TexName);
UpdateTex(tex);
texture.Name = Text;
IsReplaced = true;
Read(texture);
LoadOpenGLTexture();
LibraryGUI.UpdateViewport();
}
else
{
MessageBox.Show("Something went wrong???");
}
}
}
if (IsEditorActive() && IsReplaced)
{
UpdateEditor();
}
}
public void ImportTexture(string[] FileNames)
{
GTXTextureImporter importer = new GTXTextureImporter();
List <GTXImporterSettings> settings = new List <GTXImporterSettings>();
foreach (string name in FileNames)
{
string TextureName = Path.GetFileNameWithoutExtension(name);
string ext = Path.GetExtension(name);
ext = ext.ToLower();
if (ext == ".bftex")
{
FTEX ftex = new FTEX();
ftex.texture = new ResU.Texture();
ftex.texture.Import(name, GetResFileU());
ftex.IsEdited = true;
ftex.Read(ftex.texture);
AddNode(ftex);
}
else if (ext == ".dds" || ext == ".dds2")
{
FTEX ftex = new FTEX();
ftex.texture = new ResU.Texture();
GTXImporterSettings setting = FTEX.SetImporterSettings(name);
if (setting.DataBlockOutput != null)
{
var surface = GTXSwizzle.CreateGx2Texture(setting.DataBlockOutput[0], setting);
var tex = FTEX.FromGx2Surface(surface, setting.TexName);
ftex.UpdateTex(tex);
ftex.IsEdited = true;
ftex.Read(ftex.texture);
ftex.LoadOpenGLTexture();
AddNode(ftex);
}
}
else
{
settings.Add(FTEX.SetImporterSettings(name));
}
}
if (settings.Count == 0)
{
importer.Dispose();
}
else
{
importer.LoadSettings(settings);
if (importer.ShowDialog() == DialogResult.OK)
{
ImportTexture(settings);
settings.Clear();
GC.Collect();
Cursor.Current = Cursors.Default;
}
}
}
public override void ReplaceAll()
{
FolderSelectDialog sfd = new FolderSelectDialog();
if (sfd.ShowDialog() == DialogResult.OK)
{
if (Type == BRESGroupType.Textures)
{
GTXTextureImporter importer = new GTXTextureImporter();
List <GTXImporterSettings> settings = new List <GTXImporterSettings>();
foreach (string file in System.IO.Directory.GetFiles(sfd.SelectedPath))
{
string FileName = System.IO.Path.GetFileNameWithoutExtension(file);
foreach (FTEX ftex in Nodes)
{
if (FileName == ftex.Text)
{
string ext = Path.GetExtension(file);
ext = ext.ToLower();
if (ext == ".bftex")
{
ftex.texture = new ResU.Texture();
ftex.texture.Import(file, GetResFileU());
ftex.IsEdited = true;
ftex.Read(ftex.texture);
}
else if (ext == ".dds" || ext == ".dds2")
{
GTXImporterSettings setting = FTEX.SetImporterSettings(file);
if (setting.DataBlockOutput != null)
{
var surface = GTXSwizzle.CreateGx2Texture(setting.DataBlockOutput[0], setting);
var tex = FTEX.FromGx2Surface(surface, setting.TexName);
ftex.UpdateTex(tex);
ftex.IsReplaced = true;
ftex.Read(ftex.texture);
ftex.LoadOpenGLTexture();
}
}
else
{
var setting = FTEX.SetImporterSettings(file);
setting.MipCountOriginal = (int)ftex.MipCount;
setting.Format = (GX2.GX2SurfaceFormat)FTEX.ConvertToGx2Format(ftex.Format);
settings.Add(setting);
}
}
}
}
if (settings.Count == 0)
{
importer.Dispose();
}
else
{
importer.LoadSettings(settings);
if (importer.ShowDialog() == DialogResult.OK)
{
foreach (var setting in settings)
{
foreach (FTEX ftex in Nodes)
{
if (setting.TexName == ftex.Text)
{
if (setting.GenerateMipmaps && !setting.IsFinishedCompressing)
{
setting.DataBlockOutput.Clear();
setting.DataBlockOutput.Add(setting.GenerateMips());
}
if (setting.DataBlockOutput != null)
{
var surface = GTXSwizzle.CreateGx2Texture(setting.DataBlockOutput[0], setting);
var tex = FTEX.FromGx2Surface(surface, setting.TexName);
ftex.UpdateTex(tex);
tex.Name = ftex.Text;
ftex.IsEdited = true;
ftex.Read(ftex.texture);
ftex.LoadOpenGLTexture();
}
else
{
MessageBox.Show("Something went wrong???");
}
}
}
}
settings.Clear();
GC.Collect();
Cursor.Current = Cursors.Default;
}
}
}
else
{
foreach (string file in System.IO.Directory.GetFiles(sfd.SelectedPath))
{
string FileName = System.IO.Path.GetFileNameWithoutExtension(file);
foreach (TreeNode node in Nodes)
{
if (node is STGenericWrapper)
{
if (FileName == node.Text)
{
((STGenericWrapper)node).Replace(file);
}
}
}
}
}
}
}
public override void Replace(string FileName)
{
string ext = System.IO.Path.GetExtension(FileName);
ext = ext.ToLower();
if (ext == ".bftex")
{
texture.Import(FileName, ((BFRESGroupNode)Parent).GetResFileU());
texture.Name = Text;
IsEdited = true;
Read(texture);
if (IsEditorActive())
{
UpdateEditor();
}
return;
}
GTXImporterSettings setting = SetImporterSettings(FileName);
GTXTextureImporter importer = new GTXTextureImporter();
if (Tex2Swizzle != 0)
{
setting.swizzle = Tex2Swizzle;
}
importer.LoadSetting(setting);
if (ext == ".dds")
{
if (setting.DataBlockOutput != null)
{
var surface = setting.CreateGx2Texture(setting.DataBlockOutput[0]);
var tex = FromGx2Surface(surface, setting);
UpdateTex(tex);
texture.Name = Text;
IsEdited = true;
Read(texture);
LoadOpenGLTexture();
}
}
else
{
if (importer.ShowDialog() == DialogResult.OK)
{
Cursor.Current = Cursors.WaitCursor;
if (setting.GenerateMipmaps)
{
setting.DataBlockOutput.Clear();
setting.DataBlockOutput.Add(setting.GenerateMips());
}
if (setting.DataBlockOutput != null)
{
var surface = setting.CreateGx2Texture(setting.DataBlockOutput[0]);
var tex = FromGx2Surface(surface, setting);
UpdateTex(tex);
texture.Name = Text;
IsEdited = true;
Read(texture);
LoadOpenGLTexture();
}
else
{
MessageBox.Show("Something went wrong???");
}
}
}
if (IsEditorActive())
{
UpdateEditor();
}
}
