mirror/AssetStudio
1
0
Fork 0
mirror of https://github.com/aelurum/AssetStudio.git synced 2025-07-18 03:24:15 -04:00
Code Issues Packages Projects Releases Wiki Activity

Separate code

Browse Source 
rename
This commit is contained in:
Perfare
2018-03-01 20:01:25 +08:00
parent 9d7c3b9f64
commit c8393e165f
33 changed files with 2624 additions and 2557 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
Unity Studio/Unity Studio Classes/AssetPreloadData.cs
View File

@ -21,5 +21,15 @@ namespace Unity_Studio
public AssetsFile sourceFile;
public string uniqueID;
public EndianBinaryReader Reader
{
get
{
var reader = sourceFile.assetsFileReader;
reader.Position = Offset;
return reader;
}
}
}
}

178
Unity Studio/Unity Studio Classes/ClassStruct.cs
View File

@ -41,18 +41,17 @@ namespace Unity_Studio
{
public static string ViewStruct(this AssetPreloadData asset)
{
var a_Stream = asset.sourceFile.assetsFileReader;
a_Stream.Position = asset.Offset;
var reader = asset.Reader;
if (asset.sourceFile.ClassStructures.TryGetValue(asset.Type1, out var classStructure))
{
var sb = new StringBuilder();
ReadClassStruct(sb, classStructure.members, a_Stream);
ReadClassStruct(sb, classStructure.members, reader);
return sb.ToString();
}
return null;
}
public static void ReadClassStruct(StringBuilder sb, List<ClassMember> members, EndianBinaryReader a_Stream)
public static void ReadClassStruct(StringBuilder sb, List<ClassMember> members, EndianBinaryReader reader)
{
for (int i = 0; i < members.Count; i++)
{
@ -64,97 +63,96 @@ namespace Unity_Studio
var align = (member.Flag & 0x4000) != 0;
var append = true;
if (member.alignBefore)
a_Stream.AlignStream(4);
if (varTypeStr == "SInt8")//sbyte
reader.AlignStream(4);
switch (varTypeStr)
{
value = a_Stream.ReadSByte();
}
else if (varTypeStr == "UInt8")//byte
{
value = a_Stream.ReadByte();
}
else if (varTypeStr == "short" || varTypeStr == "SInt16")//Int16
{
value = a_Stream.ReadInt16();
}
else if (varTypeStr == "UInt16" || varTypeStr == "unsigned short")//UInt16
{
value = a_Stream.ReadUInt16();
}
else if (varTypeStr == "int" || varTypeStr == "SInt32")//Int32
{
value = a_Stream.ReadInt32();
}
else if (varTypeStr == "UInt32" || varTypeStr == "unsigned int" || varTypeStr == "Type*")//UInt32
{
value = a_Stream.ReadUInt32();
}
else if (varTypeStr == "long long" || varTypeStr == "SInt64")//Int64
{
value = a_Stream.ReadInt64();
}
else if (varTypeStr == "UInt64" || varTypeStr == "unsigned long long")//UInt64
{
value = a_Stream.ReadUInt64();
}
else if (varTypeStr == "float")//float
{
value = a_Stream.ReadSingle();
}
else if (varTypeStr == "double")//double
{
value = a_Stream.ReadDouble();
}
else if (varTypeStr == "bool")//bool
{
value = a_Stream.ReadBoolean();
}
else if (varTypeStr == "string")//string
{
append = false;
var str = a_Stream.ReadAlignedString(a_Stream.ReadInt32());
sb.AppendFormat("{0}{1} {2} = \"{3}\"\r\n", (new string('\t', level)), varTypeStr, varNameStr, str);
i += 3;//skip
}
else if (varTypeStr == "Array")//Array
{
append = false;
if ((members[i - 1].Flag & 0x4000) != 0)
align = true;
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
var size = a_Stream.ReadInt32();
sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), "int", "size", size);
var array = ReadArray(members, level, i);
for (int j = 0; j < size; j++)
{
sb.AppendFormat("{0}[{1}]\r\n", (new string('\t', level + 1)), j);
ReadClassStruct(sb, array, a_Stream);
}
i += array.Count + 1;//skip
}
else if (varTypeStr == "TypelessData")
{
append = false;
var size = a_Stream.ReadInt32();
a_Stream.ReadBytes(size);
i += 2;
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), "int", "size", size);
}
else
{
append = false;
if (align)
{
align = false;
SetAlignBefore(members, level, i + 1);
}
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
case "SInt8":
value = reader.ReadSByte();
break;
case "UInt8":
value = reader.ReadByte();
break;
case "short":
case "SInt16":
value = reader.ReadInt16();
break;
case "UInt16":
case "unsigned short":
value = reader.ReadUInt16();
break;
case "int":
case "SInt32":
value = reader.ReadInt32();
break;
case "UInt32":
case "unsigned int":
case "Type*":
value = reader.ReadUInt32();
break;
case "long long":
case "SInt64":
value = reader.ReadInt64();
break;
case "UInt64":
case "unsigned long long":
value = reader.ReadUInt64();
break;
case "float":
value = reader.ReadSingle();
break;
case "double":
value = reader.ReadDouble();
break;
case "bool":
value = reader.ReadBoolean();
break;
case "string":
append = false;
var str = reader.ReadAlignedString(reader.ReadInt32());
sb.AppendFormat("{0}{1} {2} = \"{3}\"\r\n", (new string('\t', level)), varTypeStr, varNameStr, str);
i += 3;//skip
break;
case "Array":
{
append = false;
if ((members[i - 1].Flag & 0x4000) != 0)
align = true;
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
var size = reader.ReadInt32();
sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), "int", "size", size);
var array = ReadArray(members, level, i);
for (int j = 0; j < size; j++)
{
sb.AppendFormat("{0}[{1}]\r\n", (new string('\t', level + 1)), j);
ReadClassStruct(sb, array, reader);
}
i += array.Count + 1;//skip
break;
}
case "TypelessData":
{
append = false;
var size = reader.ReadInt32();
reader.ReadBytes(size);
i += 2;
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), "int", "size", size);
break;
}
default:
append = false;
if (align)
{
align = false;
SetAlignBefore(members, level, i + 1);
}
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
break;
}
if (append)
sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), varTypeStr, varNameStr, value);
if (align)
a_Stream.AlignStream(4);
reader.AlignStream(4);
}
}

1137
Unity Studio/Unity Studio Classes/FBXExporter.cs Normal file
View File

File diff suppressed because it is too large Load Diff

76
Unity Studio/Unity Studio Classes/Helpers.cs → Unity Studio/Unity Studio Classes/PPtrHelpers.cs
View File

@ -2,10 +2,8 @@
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using static Unity_Studio.UnityStudio;
namespace Unity_Studio
{
public class PPtr
@ -88,79 +86,5 @@ namespace Unity_Studio
return false;
}
public static void ParseGameObject(this List<AssetsFile> assetsfileList, GameObject m_GameObject)
{
foreach (var m_Component in m_GameObject.m_Components)
{
if (m_Component.m_FileID >= 0 && m_Component.m_FileID < assetsfileList.Count)
{
AssetsFile sourceFile = assetsfileList[m_Component.m_FileID];
if (sourceFile.preloadTable.TryGetValue(m_Component.m_PathID, out var asset))
{
switch (asset.Type2)
{
case 4: //Transform
{
m_GameObject.m_Transform = m_Component;
break;
}
case 23: //MeshRenderer
{
m_GameObject.m_MeshRenderer = m_Component;
break;
}
case 33: //MeshFilter
{
m_GameObject.m_MeshFilter = m_Component;
break;
}
case 137: //SkinnedMeshRenderer
{
m_GameObject.m_SkinnedMeshRenderer = m_Component;
break;
}
}
}
}
}
}
}
class TexEnv
{
public string name;
public PPtr m_Texture;
public float[] m_Scale;
public float[] m_Offset;
}
class strFloatPair
{
public string first;
public float second;
}
class strColorPair
{
public string first;
public float[] second;
}
public static class StringExtensions
{
/// <summary>
/// Compares the string against a given pattern.
/// </summary>
/// <param name="str">The string.</param>
/// <param name="pattern">The pattern to match, where "*" means any sequence of characters, and "?" means any single character.</param>
/// <returns><c>true</c> if the string matches the given pattern; otherwise <c>false</c>.</returns>
public static bool Like(this string str, string pattern)
{
return new Regex(
"^" + Regex.Escape(pattern).Replace(@"\*", ".*").Replace(@"\?", ".") + "$",
RegexOptions.IgnoreCase | RegexOptions.Singleline
).IsMatch(str);
}
}
}

102
Unity Studio/Unity Studio Classes/SpriteHelper.cs Normal file
View File

@ -0,0 +1,102 @@
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Linq;
using System.Text;
using static Unity_Studio.UnityStudio;
namespace Unity_Studio
{
static class SpriteHelper
{
private static Dictionary<AssetPreloadData, Bitmap> spriteCache = new Dictionary<AssetPreloadData, Bitmap>();
public static Bitmap GetImageFromSprite(AssetPreloadData asset)
{
if (spriteCache.TryGetValue(asset, out var bitmap))
return (Bitmap)bitmap.Clone();
var m_Sprite = new Sprite(asset, true);
if (assetsfileList.TryGetPD(m_Sprite.m_SpriteAtlas, out var assetPreloadData))
{
var m_SpriteAtlas = new SpriteAtlas(assetPreloadData);
var index = m_SpriteAtlas.guids.FindIndex(x => x == m_Sprite.first);
if (index >= 0 && assetsfileList.TryGetPD(m_SpriteAtlas.textures[index], out assetPreloadData))
{
return CutImage(asset, assetPreloadData, m_SpriteAtlas.textureRects[index], m_Sprite);
}
}
else
{
if (assetsfileList.TryGetPD(m_Sprite.texture, out assetPreloadData))
{
return CutImage(asset, assetPreloadData, m_Sprite.textureRect);
}
}
return null;
}
private static Bitmap CutImage(AssetPreloadData asset, AssetPreloadData texture2DAsset, RectangleF textureRect)
{
var texture2D = new Texture2D(texture2DAsset, true);
using (var originalImage = texture2D.ConvertToBitmap(false))
{
if (originalImage != null)
{
var info = texture2DAsset.InfoText;
var start = info.IndexOf("Format");
info = info.Substring(start, info.Length - start);
asset.InfoText = $"Width: {textureRect.Width}\nHeight: {textureRect.Height}\n" + info;
var spriteImage = originalImage.Clone(textureRect, PixelFormat.Format32bppArgb);
spriteImage.RotateFlip(RotateFlipType.RotateNoneFlipY);
spriteCache.Add(asset, spriteImage);
return (Bitmap)spriteImage.Clone();
}
}
return null;
}
private static Bitmap CutImage(AssetPreloadData asset, AssetPreloadData texture2DAsset, RectangleF textureRect, Sprite sprite)
{
var texture2D = new Texture2D(texture2DAsset, true);
using (var originalImage = texture2D.ConvertToBitmap(false))
{
if (originalImage != null)
{
var info = texture2DAsset.InfoText;
var start = info.IndexOf("Format");
info = info.Substring(start, info.Length - start);
asset.InfoText = $"Width: {textureRect.Width}\nHeight: {textureRect.Height}\n" + info;
var spriteImage = originalImage.Clone(textureRect, PixelFormat.Format32bppArgb);
using (var brush = new TextureBrush(spriteImage))
{
using (var path = new GraphicsPath())
{
foreach (var p in sprite.m_PhysicsShape)
path.AddPolygon(p);
using (var matr = new Matrix())
{
matr.Translate(sprite.m_Rect.Width * sprite.m_Pivot.X, sprite.m_Rect.Height * sprite.m_Pivot.Y);
matr.Scale(sprite.m_PixelsToUnits, sprite.m_PixelsToUnits);
path.Transform(matr);
var bitmap = new Bitmap((int)textureRect.Width, (int)textureRect.Height);
using (var graphic = Graphics.FromImage(bitmap))
{
graphic.FillPath(brush, path);
bitmap.RotateFlip(RotateFlipType.RotateNoneFlipY);
spriteCache.Add(asset, bitmap);
return (Bitmap)bitmap.Clone();
}
}
}
}
}
}
return null;
}
}
}

25
Unity Studio/Unity Studio Classes/StringExtensions.cs Normal file
View File

@ -0,0 +1,25 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
namespace Unity_Studio
{
public static class StringExtensions
{
/// <summary>
/// Compares the string against a given pattern.
/// </summary>
/// <param name="str">The string.</param>
/// <param name="pattern">The pattern to match, where "*" means any sequence of characters, and "?" means any single character.</param>
/// <returns><c>true</c> if the string matches the given pattern; otherwise <c>false</c>.</returns>
public static bool Like(this string str, string pattern)
{
return new Regex(
"^" + Regex.Escape(pattern).Replace(@"\*", ".*").Replace(@"\?", ".") + "$",
RegexOptions.IgnoreCase | RegexOptions.Singleline
).IsMatch(str);
}
}
}

183
Unity Studio/Unity Studio Classes/Texture2DConverter.cs
View File

@ -354,4 +354,187 @@ namespace Unity_Studio
return bitmap;
}
}
public static class KTXHeader
{
public static byte[] IDENTIFIER = { 0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A };
public static byte[] ENDIANESS_LE = { 1, 2, 3, 4 };
public static byte[] ENDIANESS_BE = { 4, 3, 2, 1 };
// constants for glInternalFormat
public static int GL_ETC1_RGB8_OES = 0x8D64;
public static int GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 0x8C00;
public static int GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG = 0x8C01;
public static int GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 0x8C02;
public static int GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = 0x8C03;
public static int GL_ATC_RGB_AMD = 0x8C92;
public static int GL_ATC_RGBA_EXPLICIT_ALPHA_AMD = 0x8C93;
public static int GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD = 0x87EE;
public static int GL_COMPRESSED_RGB8_ETC2 = 0x9274;
public static int GL_COMPRESSED_SRGB8_ETC2 = 0x9275;
public static int GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276;
public static int GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277;
public static int GL_COMPRESSED_RGBA8_ETC2_EAC = 0x9278;
public static int GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279;
public static int GL_COMPRESSED_R11_EAC = 0x9270;
public static int GL_COMPRESSED_SIGNED_R11_EAC = 0x9271;
public static int GL_COMPRESSED_RG11_EAC = 0x9272;
public static int GL_COMPRESSED_SIGNED_RG11_EAC = 0x9273;
public static int GL_COMPRESSED_RED_RGTC1 = 0x8DBB;
public static int GL_COMPRESSED_RG_RGTC2 = 0x8DBD;
public static int GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F;
public static int GL_COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C;
public static int GL_R16F = 0x822D;
public static int GL_RG16F = 0x822F;
public static int GL_RGBA16F = 0x881A;
public static int GL_R32F = 0x822E;
public static int GL_RG32F = 0x8230;
public static int GL_RGBA32F = 0x8814;
// constants for glBaseInternalFormat
public static int GL_RED = 0x1903;
public static int GL_GREEN = 0x1904;
public static int GL_BLUE = 0x1905;
public static int GL_ALPHA = 0x1906;
public static int GL_RGB = 0x1907;
public static int GL_RGBA = 0x1908;
public static int GL_RG = 0x8227;
}
//from TextureConverter.h
public enum QFORMAT
{
// General formats
Q_FORMAT_RGBA_8UI = 1,
Q_FORMAT_RGBA_8I,
Q_FORMAT_RGB5_A1UI,
Q_FORMAT_RGBA_4444,
Q_FORMAT_RGBA_16UI,
Q_FORMAT_RGBA_16I,
Q_FORMAT_RGBA_32UI,
Q_FORMAT_RGBA_32I,
Q_FORMAT_PALETTE_8_RGBA_8888,
Q_FORMAT_PALETTE_8_RGBA_5551,
Q_FORMAT_PALETTE_8_RGBA_4444,
Q_FORMAT_PALETTE_4_RGBA_8888,
Q_FORMAT_PALETTE_4_RGBA_5551,
Q_FORMAT_PALETTE_4_RGBA_4444,
Q_FORMAT_PALETTE_1_RGBA_8888,
Q_FORMAT_PALETTE_8_RGB_888,
Q_FORMAT_PALETTE_8_RGB_565,
Q_FORMAT_PALETTE_4_RGB_888,
Q_FORMAT_PALETTE_4_RGB_565,
Q_FORMAT_R2_GBA10UI,
Q_FORMAT_RGB10_A2UI,
Q_FORMAT_RGB10_A2I,
Q_FORMAT_RGBA_F,
Q_FORMAT_RGBA_HF,
Q_FORMAT_RGB9_E5, // Last five bits are exponent bits (Read following section in GLES3 spec: "3.8.17 Shared Exponent Texture Color Conversion")
Q_FORMAT_RGB_8UI,
Q_FORMAT_RGB_8I,
Q_FORMAT_RGB_565,
Q_FORMAT_RGB_16UI,
Q_FORMAT_RGB_16I,
Q_FORMAT_RGB_32UI,
Q_FORMAT_RGB_32I,
Q_FORMAT_RGB_F,
Q_FORMAT_RGB_HF,
Q_FORMAT_RGB_11_11_10_F,
Q_FORMAT_RG_F,
Q_FORMAT_RG_HF,
Q_FORMAT_RG_32UI,
Q_FORMAT_RG_32I,
Q_FORMAT_RG_16I,
Q_FORMAT_RG_16UI,
Q_FORMAT_RG_8I,
Q_FORMAT_RG_8UI,
Q_FORMAT_RG_S88,
Q_FORMAT_R_32UI,
Q_FORMAT_R_32I,
Q_FORMAT_R_F,
Q_FORMAT_R_16F,
Q_FORMAT_R_16I,
Q_FORMAT_R_16UI,
Q_FORMAT_R_8I,
Q_FORMAT_R_8UI,
Q_FORMAT_LUMINANCE_ALPHA_88,
Q_FORMAT_LUMINANCE_8,
Q_FORMAT_ALPHA_8,
Q_FORMAT_LUMINANCE_ALPHA_F,
Q_FORMAT_LUMINANCE_F,
Q_FORMAT_ALPHA_F,
Q_FORMAT_LUMINANCE_ALPHA_HF,
Q_FORMAT_LUMINANCE_HF,
Q_FORMAT_ALPHA_HF,
Q_FORMAT_DEPTH_16,
Q_FORMAT_DEPTH_24,
Q_FORMAT_DEPTH_24_STENCIL_8,
Q_FORMAT_DEPTH_32,
Q_FORMAT_BGR_565,
Q_FORMAT_BGRA_8888,
Q_FORMAT_BGRA_5551,
Q_FORMAT_BGRX_8888,
Q_FORMAT_BGRA_4444,
// Compressed formats
Q_FORMAT_ATITC_RGBA,
Q_FORMAT_ATC_RGBA_EXPLICIT_ALPHA = Q_FORMAT_ATITC_RGBA,
Q_FORMAT_ATITC_RGB,
Q_FORMAT_ATC_RGB = Q_FORMAT_ATITC_RGB,
Q_FORMAT_ATC_RGBA_INTERPOLATED_ALPHA,
Q_FORMAT_ETC1_RGB8,
Q_FORMAT_3DC_X,
Q_FORMAT_3DC_XY,
Q_FORMAT_ETC2_RGB8,
Q_FORMAT_ETC2_RGBA8,
Q_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1,
Q_FORMAT_ETC2_SRGB8,
Q_FORMAT_ETC2_SRGB8_ALPHA8,
Q_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1,
Q_FORMAT_EAC_R_SIGNED,
Q_FORMAT_EAC_R_UNSIGNED,
Q_FORMAT_EAC_RG_SIGNED,
Q_FORMAT_EAC_RG_UNSIGNED,
Q_FORMAT_S3TC_DXT1_RGB,
Q_FORMAT_S3TC_DXT1_RGBA,
Q_FORMAT_S3TC_DXT3_RGBA,
Q_FORMAT_S3TC_DXT5_RGBA,
// YUV formats
Q_FORMAT_AYUV_32,
Q_FORMAT_I444_24,
Q_FORMAT_YUYV_16,
Q_FORMAT_UYVY_16,
Q_FORMAT_I420_12,
Q_FORMAT_YV12_12,
Q_FORMAT_NV21_12,
Q_FORMAT_NV12_12,
// ASTC Format
Q_FORMAT_ASTC_8,
Q_FORMAT_ASTC_16,
};
public enum texgenpack_texturetype
{
RGTC1,
RGTC2,
BPTC_FLOAT,
BPTC
}
}

320
Unity Studio/Unity Studio Classes/UnityExporter.cs Normal file
View File

@ -0,0 +1,320 @@
using System;
using System.Collections.Generic;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using static Unity_Studio.SpriteHelper;
namespace Unity_Studio
{
static class UnityExporter
{
public static bool ExportTexture2D(AssetPreloadData asset, string exportPathName, bool flip)
{
var m_Texture2D = new Texture2D(asset, true);
if (m_Texture2D.image_data == null)
return false;
var convert = (bool)Properties.Settings.Default["convertTexture"];
var bitmap = m_Texture2D.ConvertToBitmap(flip);
if (convert && bitmap != null)
{
ImageFormat format = null;
var ext = (string)Properties.Settings.Default["convertType"];
switch (ext)
{
case "BMP":
format = ImageFormat.Bmp;
break;
case "PNG":
format = ImageFormat.Png;
break;
case "JPEG":
format = ImageFormat.Jpeg;
break;
}
var exportFullName = exportPathName + asset.Text + "." + ext.ToLower();
if (ExportFileExists(exportFullName))
return false;
bitmap.Save(exportFullName, format);
bitmap.Dispose();
return true;
}
if (!convert)
{
var exportFullName = exportPathName + asset.Text + asset.extension;
if (ExportFileExists(exportFullName))
return false;
File.WriteAllBytes(exportFullName, m_Texture2D.ConvertToContainer());
return true;
}
return false;
}
public static bool ExportAudioClip(AssetPreloadData asset, string exportPath)
{
var m_AudioClip = new AudioClip(asset, true);
if (m_AudioClip.m_AudioData == null)
return false;
var convertAudio = (bool)Properties.Settings.Default["convertAudio"];
if (convertAudio && m_AudioClip.IsFMODSupport)
{
var exportFullName = exportPath + asset.Text + ".wav";
if (ExportFileExists(exportFullName))
return false;
FMOD.CREATESOUNDEXINFO exinfo = new FMOD.CREATESOUNDEXINFO();
var result = FMOD.Factory.System_Create(out var system);
if (result != FMOD.RESULT.OK)
return false;
result = system.init(1, FMOD.INITFLAGS.NORMAL, IntPtr.Zero);
if (result != FMOD.RESULT.OK)
return false;
exinfo.cbsize = Marshal.SizeOf(exinfo);
exinfo.length = (uint)m_AudioClip.m_Size;
result = system.createSound(m_AudioClip.m_AudioData, FMOD.MODE.OPENMEMORY, ref exinfo, out var sound);
if (result != FMOD.RESULT.OK)
return false;
result = sound.getSubSound(0, out var subsound);
if (result != FMOD.RESULT.OK)
return false;
result = subsound.getFormat(out var type, out var format, out int NumChannels, out int BitsPerSample);
if (result != FMOD.RESULT.OK)
return false;
result = subsound.getDefaults(out var frequency, out int priority);
if (result != FMOD.RESULT.OK)
return false;
var SampleRate = (int)frequency;
result = subsound.getLength(out var length, FMOD.TIMEUNIT.PCMBYTES);
if (result != FMOD.RESULT.OK)
return false;
result = subsound.@lock(0, length, out var ptr1, out var ptr2, out var len1, out var len2);
if (result != FMOD.RESULT.OK)
return false;
byte[] buffer = new byte[len1 + 44];
//添加wav头
Encoding.UTF8.GetBytes("RIFF").CopyTo(buffer, 0);
BitConverter.GetBytes(len1 + 36).CopyTo(buffer, 4);
Encoding.UTF8.GetBytes("WAVEfmt ").CopyTo(buffer, 8);
BitConverter.GetBytes(16).CopyTo(buffer, 16);
BitConverter.GetBytes((short)1).CopyTo(buffer, 20);
BitConverter.GetBytes((short)NumChannels).CopyTo(buffer, 22);
BitConverter.GetBytes(SampleRate).CopyTo(buffer, 24);
BitConverter.GetBytes(SampleRate * NumChannels * BitsPerSample / 8).CopyTo(buffer, 28);
BitConverter.GetBytes((short)(NumChannels * BitsPerSample / 8)).CopyTo(buffer, 32);
BitConverter.GetBytes((short)BitsPerSample).CopyTo(buffer, 34);
Encoding.UTF8.GetBytes("data").CopyTo(buffer, 36);
BitConverter.GetBytes(len1).CopyTo(buffer, 40);
Marshal.Copy(ptr1, buffer, 44, (int)len1);
File.WriteAllBytes(exportFullName, buffer);
result = subsound.unlock(ptr1, ptr2, len1, len2);
if (result != FMOD.RESULT.OK)
return false;
subsound.release();
sound.release();
system.release();
}
else
{
var exportFullName = exportPath + asset.Text + asset.extension;
if (ExportFileExists(exportFullName))
return false;
File.WriteAllBytes(exportFullName, m_AudioClip.m_AudioData);
}
return true;
}
public static bool ExportShader(AssetPreloadData asset, string exportPath)
{
var m_Shader = new Shader(asset, true);
var exportFullName = exportPath + asset.Text + asset.extension;
if (ExportFileExists(exportFullName))
return false;
File.WriteAllBytes(exportFullName, m_Shader.m_Script);
return true;
}
public static bool ExportTextAsset(AssetPreloadData asset, string exportPath)
{
var m_TextAsset = new TextAsset(asset, true);
var exportFullName = exportPath + asset.Text + asset.extension;
if (ExportFileExists(exportFullName))
return false;
File.WriteAllBytes(exportFullName, m_TextAsset.m_Script);
return true;
}
public static bool ExportMonoBehaviour(AssetPreloadData asset, string exportPath)
{
var m_MonoBehaviour = new MonoBehaviour(asset, true);
var exportFullName = exportPath + asset.Text + asset.extension;
if (ExportFileExists(exportFullName))
return false;
File.WriteAllText(exportFullName, m_MonoBehaviour.serializedText);
return true;
}
public static bool ExportFont(AssetPreloadData asset, string exportPath)
{
var m_Font = new UnityFont(asset, true);
if (m_Font.m_FontData != null)
{
var exportFullName = exportPath + asset.Text + asset.extension;
if (ExportFileExists(exportFullName))
return false;
File.WriteAllBytes(exportFullName, m_Font.m_FontData);
return true;
}
return false;
}
public static bool ExportMesh(AssetPreloadData asset, string exportPath)
{
var m_Mesh = new Mesh(asset, true);
if (m_Mesh.m_VertexCount <= 0)
return false;
var exportFullName = exportPath + asset.Text + asset.extension;
if (ExportFileExists(exportFullName))
return false;
var sb = new StringBuilder();
sb.AppendLine("g " + m_Mesh.m_Name);
#region Vertices
int c = 3;
if (m_Mesh.m_Vertices.Length == m_Mesh.m_VertexCount * 4)
{
c = 4;
}
for (int v = 0; v < m_Mesh.m_VertexCount; v++)
{
sb.AppendFormat("v {0} {1} {2}\r\n", -m_Mesh.m_Vertices[v * c], m_Mesh.m_Vertices[v * c + 1], m_Mesh.m_Vertices[v * c + 2]);
}
#endregion
#region UV
if (m_Mesh.m_UV1 != null && m_Mesh.m_UV1.Length == m_Mesh.m_VertexCount * 2)
{
for (int v = 0; v < m_Mesh.m_VertexCount; v++)
{
sb.AppendFormat("vt {0} {1}\r\n", m_Mesh.m_UV1[v * 2], m_Mesh.m_UV1[v * 2 + 1]);
}
}
else if (m_Mesh.m_UV2 != null && m_Mesh.m_UV2.Length == m_Mesh.m_VertexCount * 2)
{
for (int v = 0; v < m_Mesh.m_VertexCount; v++)
{
sb.AppendFormat("vt {0} {1}\r\n", m_Mesh.m_UV2[v * 2], m_Mesh.m_UV2[v * 2 + 1]);
}
}
#endregion
#region Normals
if (m_Mesh.m_Normals != null && m_Mesh.m_Normals.Length > 0)
{
if (m_Mesh.m_Normals.Length == m_Mesh.m_VertexCount * 3)
{
c = 3;
}
else if (m_Mesh.m_Normals.Length == m_Mesh.m_VertexCount * 4)
{
c = 4;
}
for (int v = 0; v < m_Mesh.m_VertexCount; v++)
{
sb.AppendFormat("vn {0} {1} {2}\r\n", -m_Mesh.m_Normals[v * c], m_Mesh.m_Normals[v * c + 1], m_Mesh.m_Normals[v * c + 2]);
}
}
#endregion
#region Face
int sum = 0;
for (var i = 0; i < m_Mesh.m_SubMeshes.Count; i++)
{
sb.AppendLine($"g {m_Mesh.m_Name}_{i}");
int indexCount = (int)m_Mesh.m_SubMeshes[i].indexCount;
var end = sum + indexCount / 3;
for (int f = sum; f < end; f++)
{
sb.AppendFormat("f {0}/{0}/{0} {1}/{1}/{1} {2}/{2}/{2}\r\n", m_Mesh.m_Indices[f * 3 + 2] + 1, m_Mesh.m_Indices[f * 3 + 1] + 1, m_Mesh.m_Indices[f * 3] + 1);
}
sum = end;
}
#endregion
sb.Replace("NaN", "0");
File.WriteAllText(exportFullName, sb.ToString());
return true;
}
public static bool ExportVideoClip(AssetPreloadData asset, string exportPath)
{
var m_VideoClip = new VideoClip(asset, true);
if (m_VideoClip.m_VideoData != null)
{
var exportFullName = exportPath + asset.Text + asset.extension;
if (ExportFileExists(exportFullName))
return false;
File.WriteAllBytes(exportFullName, m_VideoClip.m_VideoData);
return true;
}
return false;
}
public static bool ExportMovieTexture(AssetPreloadData asset, string exportPath)
{
var m_MovieTexture = new MovieTexture(asset, true);
var exportFullName = exportPath + asset.Text + asset.extension;
if (ExportFileExists(exportFullName))
return false;
File.WriteAllBytes(exportFullName, m_MovieTexture.m_MovieData);
return true;
}
public static bool ExportSprite(AssetPreloadData asset, string exportPath)
{
ImageFormat format = null;
var type = (string)Properties.Settings.Default["convertType"];
switch (type)
{
case "BMP":
format = ImageFormat.Bmp;
break;
case "PNG":
format = ImageFormat.Png;
break;
case "JPEG":
format = ImageFormat.Jpeg;
break;
}
var exportFullName = exportPath + asset.Text + "." + type.ToLower();
if (ExportFileExists(exportFullName))
return false;
var bitmap = GetImageFromSprite(asset);
if (bitmap != null)
{
bitmap.Save(exportFullName, format);
return true;
}
return false;
}
public static bool ExportRawFile(AssetPreloadData asset, string exportPath)
{
var exportFullName = exportPath + asset.Text + asset.extension;
if (ExportFileExists(exportFullName))
return false;
var bytes = asset.Reader.ReadBytes(asset.Size);
File.WriteAllBytes(exportFullName, bytes);
return true;
}
private static bool ExportFileExists(string filename)
{
if (File.Exists(filename))
{
return true;
}
Directory.CreateDirectory(Path.GetDirectoryName(filename));
return false;
}
}
}

151
Unity Studio/Unity Studio Classes/UnityImporter.cs Normal file
View File

@ -0,0 +1,151 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using static Unity_Studio.UnityStudio;
namespace Unity_Studio
{
static class UnityImporter
{
public static List<string> unityFiles = new List<string>(); //files to load
public static HashSet<string> unityFilesHash = new HashSet<string>(); //to improve the loading speed
public static HashSet<string> assetsfileListHash = new HashSet<string>(); //to improve the loading speed
public static void LoadFile(string fullName)
{
if (CheckBundleFile(fullName, out var reader))
{
LoadBundleFile(fullName, reader);
}
else
{
LoadAssetsFile(fullName, reader);
}
}
private static void LoadAssetsFile(string fullName, EndianBinaryReader reader)
{
var fileName = Path.GetFileName(fullName);
StatusStripUpdate("Loading " + fileName);
if (!assetsfileListHash.Contains(fileName.ToUpper()))
{
var assetsFile = new AssetsFile(fullName, reader);
if (assetsFile.valid)
{
assetsfileList.Add(assetsFile);
assetsfileListHash.Add(assetsFile.upperFileName);
#region for 2.6.x find mainData and get string version
if (assetsFile.fileGen == 6 && fileName != "mainData")
{
var mainDataFile = assetsfileList.Find(aFile => aFile.fileName == "mainData");
if (mainDataFile != null)
{
assetsFile.m_Version = mainDataFile.m_Version;
assetsFile.version = mainDataFile.version;
assetsFile.buildType = mainDataFile.buildType;
}
else if (File.Exists(Path.GetDirectoryName(fullName) + "\\mainData"))
{
mainDataFile = new AssetsFile(Path.GetDirectoryName(fullName) + "\\mainData", new EndianBinaryReader(File.OpenRead(Path.GetDirectoryName(fullName) + "\\mainData")));
assetsFile.m_Version = mainDataFile.m_Version;
assetsFile.version = mainDataFile.version;
assetsFile.buildType = mainDataFile.buildType;
}
}
#endregion
int value = 0;
foreach (var sharedFile in assetsFile.sharedAssetsList)
{
var sharedFilePath = Path.GetDirectoryName(fullName) + "\\" + sharedFile.fileName;
var sharedFileName = sharedFile.fileName;
if (!unityFilesHash.Contains(sharedFileName.ToUpper()))
{
if (!File.Exists(sharedFilePath))
{
var findFiles = Directory.GetFiles(Path.GetDirectoryName(fullName), sharedFileName, SearchOption.AllDirectories);
if (findFiles.Length > 0)
{
sharedFilePath = findFiles[0];
}
}
if (File.Exists(sharedFilePath))
{
unityFiles.Add(sharedFilePath);
unityFilesHash.Add(sharedFileName.ToUpper());
value++;
}
}
}
if (value > 0)
ProgressBarMaximumAdd(value);
}
}
}
private static void LoadBundleFile(string fullName, EndianBinaryReader reader)
{
var fileName = Path.GetFileName(fullName);
StatusStripUpdate("Decompressing " + fileName);
var bundleFile = new BundleFile(reader);
foreach (var memFile in bundleFile.MemoryAssetsFileList)
{
if (!assetsfileListHash.Contains(memFile.fileName.ToUpper()))
{
StatusStripUpdate("Loading " + memFile.fileName);
var assetsFile = new AssetsFile(Path.GetDirectoryName(fullName) + "\\" + memFile.fileName, new EndianBinaryReader(memFile.memStream));
if (assetsFile.valid)
{
assetsFile.bundlePath = fullName;
if (assetsFile.fileGen == 6) //2.6.x and earlier don't have a string version before the preload table
{
//make use of the bundle file version
assetsFile.m_Version = bundleFile.versionEngine;
assetsFile.version = Array.ConvertAll((from Match m in Regex.Matches(assetsFile.m_Version, @"[0-9]") select m.Value).ToArray(), int.Parse);
assetsFile.buildType = bundleFile.versionEngine.Split(AssetsFile.buildTypeSplit, StringSplitOptions.RemoveEmptyEntries);
}
assetsfileList.Add(assetsFile);
assetsfileListHash.Add(assetsFile.upperFileName);
}
else
{
resourceFileReaders.Add(assetsFile.upperFileName, assetsFile.assetsFileReader);
}
}
}
reader.Dispose();
}
public static void MergeSplitAssets(string dirPath)
{
string[] splitFiles = Directory.GetFiles(dirPath, "*.split0");
foreach (var splitFile in splitFiles)
{
string destFile = Path.GetFileNameWithoutExtension(splitFile);
string destPath = Path.GetDirectoryName(splitFile) + "\\";
var destFull = destPath + destFile;
if (!File.Exists(destFull))
{
string[] splitParts = Directory.GetFiles(destPath, destFile + ".split*");
using (var destStream = File.Create(destFull))
{
for (int i = 0; i < splitParts.Length; i++)
{
string splitPart = destFull + ".split" + i;
using (var sourceStream = File.OpenRead(splitPart))
sourceStream.CopyTo(destStream);
}
}
}
}
}
}
}

1691
Unity Studio/Unity Studio Classes/UnityStudio.cs
View File

File diff suppressed because it is too large Load Diff