private static void CreateExporter(ExportPackageOptions exportPackageOptions, string path)
{
LogUtility.LogInfo("Creating Exporter");
ModToolSettings modToolSettings = ModToolSettings.instance;
CodeSettings codeSettings = CodeSettings.instance;
string modToolDirectory = AssetUtility.GetModToolDirectory();
string exporterPath = Path.Combine(modToolDirectory, Path.Combine("Editor", "ModTool.Exporting.Editor.dll"));
string fileName = Path.Combine(path, Application.productName + " Mod Tools.unitypackage");
List <string> assetPaths = new List <string>
{
AssetDatabase.GetAssetPath(modToolSettings),
AssetDatabase.GetAssetPath(codeSettings),
Path.Combine(modToolDirectory, Path.Combine("Editor", "ModTool.Exporting.Editor.dll")),
Path.Combine(modToolDirectory, Path.Combine("Editor", "ModTool.Shared.Editor.dll")),
Path.Combine(modToolDirectory, "ModTool.Shared.dll"),
Path.Combine(modToolDirectory, "ModTool.Shared.xml"),
Path.Combine(modToolDirectory, "ModTool.Interface.dll"),
Path.Combine(modToolDirectory, "ModTool.Interface.xml"),
Path.Combine(modToolDirectory, Path.Combine("Mono.Cecil", "Mono.Cecil.dll")),
Path.Combine(modToolDirectory, Path.Combine("Mono.Cecil", "LICENSE.txt"))
};
List <string> assemblyPaths = GetApiAssemblyPaths(CodeSettings.apiAssemblies);
AssetUtility.MoveAssets(assemblyPaths, modToolDirectory);
assetPaths.AddRange(assemblyPaths);
SetPluginEnabled(exporterPath, true);
AssetDatabase.ExportPackage(assetPaths.ToArray(), fileName, exportPackageOptions | ExportPackageOptions.IncludeLibraryAssets);
}
public virtual void UpdateOptions()
{
if (!IncludeDependencies && !IncludeLibraryAssets && !Interactive && !Recurse)
{
Options = ExportPackageOptions.Default;
}
else
{
if (IncludeDependencies)
{
Options |= ExportPackageOptions.IncludeDependencies;
}
if (IncludeLibraryAssets)
{
Options |= ExportPackageOptions.IncludeLibraryAssets;
}
if (Interactive)
{
Options |= ExportPackageOptions.Interactive;
}
if (Recurse)
{
Options |= ExportPackageOptions.Recurse;
}
}
}
public static void ExportPackage(string assetPathName, string fileName, ExportPackageOptions flags)
{
AssetDatabase.ExportPackage(new string[]
{
assetPathName
}, fileName, flags);
}
void CreatePackage(params string[] extraFiles)
{
var paths = new HashSet <string>();
var allObjects = AssetsDependencies;
allObjects.UnionWith(m_ExtraPackageObjects);
foreach (var obj in allObjects)
{
if (obj != null)
{
paths.Add(AssetDatabase.GetAssetPath(obj));
}
}
foreach (var docFile in m_ExtraGeneratedFiles)
{
paths.Add(docFile);
}
paths.UnionWith(extraFiles);
string file = EditorUtility.SaveFilePanel("Package save location", Directory.GetCurrentDirectory(), name, "unityPackage");
if (string.IsNullOrEmpty(file) == false)
{
ExportPackageOptions flags = ExportPackageOptions.Recurse | ExportPackageOptions.IncludeDependencies;
AssetDatabase.ExportPackage(paths.ToArray(), file, flags);
}
}
private static void Export(ExportPackageOptions exportPackageOptions)
{
var selectedObjs = Selection.objects;
var assetPathNames = new string[selectedObjs.Length];
for (var i = 0; i < selectedObjs.Length; i++)
{
assetPathNames[i] = AssetDatabase.GetAssetPath(selectedObjs[i]);
}
var packageName = "packageName";
if (selectedObjs.Length == 1)
{
packageName = selectedObjs[0].name;
}
var savePath = EditorUtility.SaveFilePanel("Save package to folder", "", packageName, "unitypackage");
if (string.IsNullOrEmpty(savePath))
{
return;
}
AssetDatabase.ExportPackage(assetPathNames, savePath, exportPackageOptions);
EditorUtility.DisplayDialog("Export done", "To path : " + savePath, "OK");
EditorUtility.RevealInFinder(savePath);
}
static void Exprot()
{
var targetPath = "Assets/Code/BDFramework.Game/ILRuntime/Binding/Analysis";
//1.分析之前先删除,然后生成临时文件防止报错
if (Directory.Exists(targetPath))
{
Directory.Delete(targetPath, true);
}
var fileContent = @"
namespace ILRuntime.Runtime.Generated
{
class CLRBindings
{
internal static ILRuntime.Runtime.Enviorment.ValueTypeBinder<UnityEngine.Vector2> s_UnityEngine_Vector2_Binding_Binder = null;
internal static ILRuntime.Runtime.Enviorment.ValueTypeBinder<UnityEngine.Vector3> s_UnityEngine_Vector3_Binding_Binder = null;
internal static ILRuntime.Runtime.Enviorment.ValueTypeBinder<UnityEngine.Vector4> s_UnityEngine_Vector4_Binding_Binder = null;
internal static ILRuntime.Runtime.Enviorment.ValueTypeBinder<UnityEngine.Quaternion> s_UnityEngine_Quaternion_Binding_Binder = null;
public static void Initialize(ILRuntime.Runtime.Enviorment.AppDomain app)
{
}
}
} ";
FileHelper.WriteAllText(targetPath + "/CLRBindings.cs", fileContent);
AssetDatabase.Refresh();
var exporterDirectoryList = new string[] {
"Assets/3rdPlugins/Dotween", // 第三方查件
"Assets/Code/BDFramework.Game", //Game
"Assets/Scenes", //Scene
"Assets/Packages", //Nuget
};
var exportAssets = new List <string>();
foreach (var direct in exporterDirectoryList)
{
var fs = Directory.GetFiles(direct, "*.*", SearchOption.AllDirectories);
exportAssets.AddRange(fs);
}
var exportfs = exportAssets.Where((ex) => !ex.EndsWith(".meta")).ToArray();
//版本信息添加
var path = AssetDatabase.GUIDToAssetPath("924d970067c935c4f8b818e6b4ab9e07");
File.WriteAllText(path, BDEditorApplication.BDFrameConfig.Version);
AssetDatabase.Refresh();
//导出
ExportPackageOptions op = ExportPackageOptions.Default;
var packagePath = AssetDatabase.GUIDToAssetPath("69227cf6ea5304641ae95ffb93874014");
//AssetDatabase.ImportPackage(packagePath,true);
AssetDatabase.ExportPackage(exportfs, packagePath, op);
//重新生成clr分析文件
EditorWindow_ScriptBuildDll.GenCLRBindingByAnalysis();
//debug
Debug.Log("导出成功:" + packagePath);
}
private void DrawExportUInject()
{
EditorGUILayout.LabelField("Export uInject Unity Package");
if (GUILayout.Button("Export"))
{
ExportPackageOptions options = ExportPackageOptions.Interactive | ExportPackageOptions.Recurse;
AssetDatabase.ExportPackage("Assets/uInject Base", "uInject.unitypackage", options);
}
}
public static void SampleUnityPackage()
{
var assetPathNames = new[] { "Assets/Scrmizu.Sample" };
const string fileName = "Scrmizu.Sample.unitypackage";
const ExportPackageOptions
options = ExportPackageOptions.Recurse | ExportPackageOptions.IncludeDependencies;
AssetDatabase.ExportPackage(assetPathNames, fileName, options);
}
static void Export()
{
string directory = new DirectoryInfo(Application.dataPath + "/..").FullName;
string exportPath = "Assets/Plugins/SouthPointe";
ExportPackageOptions options = ExportPackageOptions.Recurse | ExportPackageOptions.Default;
string path = EditorUtility.SaveFilePanel("Export Package", directory, "msgpack-unity", "unitypackage");
AssetDatabase.ExportPackage(exportPath, path, options);
Debug.LogFormat("Package exported to: {0}", path);
}
// ######################## FUNCTIONALITY ######################## //
#region FUNCTIONALITY
public void Export()
{
ExportPackageOptions exportFlags = ExportPackageOptions.Recurse;
if (_showPackageAfterExport)
{
exportFlags |= ExportPackageOptions.Interactive;
}
AssetDatabase.ExportPackage(_paths, $"{_targetPath}/{_packageName}.unitypackage", exportFlags);
}
private void Export(string iPath, string oPath)
{
List <string> tempList = new List <string>();
tempList.AddRange(Directory.GetFiles(iPath, "*.*"));
tempList.AddRange(Directory.GetDirectories(iPath));
string exportPackage = oPath + $"/{packageName}.unitypackage";
ExportPackageOptions exportFlags = ExportPackageOptions.Default | ExportPackageOptions.Recurse;
AssetDatabase.ExportPackage(tempList.ToArray(), exportPackage, exportFlags);
}
public static void PackageDemo()
{
string[] assetPaths = new string[]
{
"Assets/SysFont/Demo"
};
string packagePath = "unity-sysfont-demo.unitypackage";
ExportPackageOptions options = ExportPackageOptions.Recurse;
AssetDatabase.ExportPackage(assetPaths, packagePath, options);
}
public static void PackageCompatNGUI()
{
string[] assetPaths = new string[]
{
"Assets/SysFont/Compatibility"
};
string packagePath = "unity-sysfont-ngui.unitypackage";
ExportPackageOptions options = ExportPackageOptions.Recurse;
AssetDatabase.ExportPackage(assetPaths, packagePath, options);
}
private void Export()
{
UnityEngine.Object[] selectedAsset = Selection.GetFiltered(typeof(UnityEngine.Object), SelectionMode.DeepAssets);
List <string> list = new List <string>();
for (int i = 0; i < selectedAsset.Length; i++)
{
list.Add(AssetDatabase.GetAssetPath(selectedAsset[i]));
}
ExportPackageOptions op = ExportPackageOptions.IncludeDependencies | ExportPackageOptions.Recurse;
AssetDatabase.ExportPackage(list.ToArray(), output_path + "\\VRworkshopX.unitypackage", op);
}
public static void ExprotCasinosNative()
{
UnityEngine.Object[] selected_asset = Selection.GetFiltered(typeof(UnityEngine.Object), SelectionMode.DeepAssets);
List <string> list = new List <string>();
for (int i = 0; i < selected_asset.Length; i++)
{
list.Add(AssetDatabase.GetAssetPath(selected_asset[i]));
}
ExportPackageOptions op = ExportPackageOptions.IncludeDependencies | ExportPackageOptions.Recurse;
AssetDatabase.ExportPackage(list.ToArray(), "./CasinosNative.unitypackage", op);
Debug.Log("导出CasinosNative.unitypackage成功！");
}
static void Exprot()
{
var targetPath = "Assets/Code/BDFramework.Game/ILRuntime/Binding/Analysis";
//1.分析之前先删除,然后生成临时文件防止报错
if (Directory.Exists(targetPath))
{
Directory.Delete(targetPath, true);
}
var fileContent = @"
namespace ILRuntime.Runtime.Generated
{
class CLRBindings
{
internal static ILRuntime.Runtime.Enviorment.ValueTypeBinder<UnityEngine.Vector2> s_UnityEngine_Vector2_Binding_Binder = null;
internal static ILRuntime.Runtime.Enviorment.ValueTypeBinder<UnityEngine.Vector3> s_UnityEngine_Vector3_Binding_Binder = null;
internal static ILRuntime.Runtime.Enviorment.ValueTypeBinder<UnityEngine.Vector4> s_UnityEngine_Vector4_Binding_Binder = null;
internal static ILRuntime.Runtime.Enviorment.ValueTypeBinder<UnityEngine.Quaternion> s_UnityEngine_Quaternion_Binding_Binder = null;
public static void Initialize(ILRuntime.Runtime.Enviorment.AppDomain app)
{
}
}
} ";
FileHelper.WriteAllText(targetPath + "/CLRBindings.cs", fileContent);
AssetDatabase.Refresh();
var exporterDirectoryList = new string[] { "Assets/Code/BDFramework.Game", "Assets/Scenes", };
var exportAssets = new List <string>();
foreach (var direct in exporterDirectoryList)
{
var fs = Directory.GetFiles(direct, "*.*", SearchOption.AllDirectories);
exportAssets.AddRange(fs);
}
var exportfs = exportAssets.Where((ex) => !ex.EndsWith(".meta")).ToArray();
//导出
ExportPackageOptions op = ExportPackageOptions.Default;
var packagePath = AssetDatabase.GUIDToAssetPath("69227cf6ea5304641ae95ffb93874014");
//AssetDatabase.ImportPackage(packagePath,true);
AssetDatabase.ExportPackage(exportfs, packagePath, op);
Debug.Log("导出成功:" + packagePath);
}
public static void PackageCore()
{
string[] assetPaths = new string[]
{
"Assets/Plugins/iOS",
"Assets/Plugins/SysFont",
"Assets/Plugins/SysFont.bundle",
"Assets/Plugins/Android",
"Assets/SysFont/Editor",
"Assets/SysFont/Resources"
};
string packagePath = "unity-sysfont.unitypackage";
ExportPackageOptions options = ExportPackageOptions.Recurse;
AssetDatabase.ExportPackage(assetPaths, packagePath, options);
}
public static void PackageDemo()
{
string[] assetPaths = new string[]
{
"Assets/URLClient/Demo"
};
ImportAssetOptions importOpts = ImportAssetOptions.Default;
importOpts |= ImportAssetOptions.ForceSynchronousImport;
importOpts |= ImportAssetOptions.ImportRecursive;
AssetDatabase.Refresh(importOpts);
string packagePath = "unity-urlclient-demo.unitypackage";
ExportPackageOptions exportOpts = ExportPackageOptions.Recurse;
AssetDatabase.ExportPackage(assetPaths, packagePath, exportOpts);
}
private static void ExportPackage(string[] files, string exportName, ExportPackageOptions[] optionsArray)
{
if (!CheckFilesExist(files))
{
return;
}
var exportFullName = AddExportExtension(exportName);
ExportPackageOptions exportOptions = ExportPackageOptions.Default;
foreach (var options in optionsArray)
{
exportOptions |= options;
}
AssetDatabase.ExportPackage(files, exportFullName, exportOptions);
Debug.LogFormat("Exported to: {0}\nExported: {1}", exportFullName, string.Join("\n", files));
}
private void DrawExportModules()
{
Settings s = (Settings)target;
if (s.exportPaths.Count == 0 || s.exportPaths.Last() != "")
{
s.exportPaths.Add("");
}
EditorGUILayout.LabelField("Export Modules");
for (int i = 0; i < s.exportPaths.Count; i++)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Module");
s.exportPaths[i] = EditorGUILayout.TextField(s.exportPaths[i]);
if (GUILayout.Button("X"))
{
s.exportPaths.RemoveAt(i);
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.PrefixLabel("Module");
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Package Name");
s.packageName = EditorGUILayout.TextField(s.packageName);
EditorGUILayout.EndHorizontal();
if (GUILayout.Button("Export"))
{
if (!s.packageName.EndsWith(".unitypackage"))
{
s.packageName += ".unitypackage";
}
s.exportPaths.RemoveAt(s.exportPaths.Count - 1);
for (int i = 0; i < s.exportPaths.Count; i++)
{
if (!s.exportPaths[i].StartsWith("Assets/"))
{
s.exportPaths[i] = "Assets/" + s.exportPaths[i];
}
}
ExportPackageOptions options = ExportPackageOptions.Interactive | ExportPackageOptions.Recurse | ExportPackageOptions.IncludeDependencies;
AssetDatabase.ExportPackage(s.exportPaths.ToArray(), s.packageName, options);
}
}
static void Exprot()
{
var exporterDirectoryList = new string[] { "Assets/Code/BDFramework.Game", "Assets/Scenes", };
var exportAssets = new List <string>();
foreach (var direct in exporterDirectoryList)
{
var fs = Directory.GetFiles(direct, "*.*", SearchOption.AllDirectories);
exportAssets.AddRange(fs);
}
var exportfs = exportAssets.Where((ex) => !ex.EndsWith(".meta")).ToArray();
//导出
ExportPackageOptions op = ExportPackageOptions.Default;
var packagePath = AssetDatabase.GUIDToAssetPath("69227cf6ea5304641ae95ffb93874014");
//AssetDatabase.ImportPackage(packagePath,true);
AssetDatabase.ExportPackage(exportfs, packagePath, op);
Debug.Log("导出成功:" + packagePath);
}
public static void PackageCore()
{
string[] assetPaths = new string[]
{
"Assets/Plugins/URLClient",
"Assets/Plugins/URLClient.bundle",
"Assets/Plugins/iOS",
"Assets/Plugins/Android",
"Assets/Editor/URLClient"
};
ImportAssetOptions importOpts = ImportAssetOptions.Default;
importOpts |= ImportAssetOptions.ForceSynchronousImport;
importOpts |= ImportAssetOptions.ImportRecursive;
AssetDatabase.Refresh(importOpts);
string packagePath = "unity-urlclient.unitypackage";
ExportPackageOptions exportOpts = ExportPackageOptions.Recurse;
AssetDatabase.ExportPackage(assetPaths, packagePath, exportOpts);
}
public static void PackageCore()
{
string[] assetPaths = new string[]
{
"Assets/Countly/Editor",
"Assets/Plugins/Countly",
"Assets/Plugins/iOS/UnityCountly.mm",
"Assets/Plugins/Android/Countly.jar"
};
string packagePath = "unity-countly.unitypackage";
ImportAssetOptions importOpts = ImportAssetOptions.Default;
importOpts |= ImportAssetOptions.ForceSynchronousImport;
importOpts |= ImportAssetOptions.ImportRecursive;
AssetDatabase.Refresh(importOpts);
ExportPackageOptions exportOpts = ExportPackageOptions.Recurse;
AssetDatabase.ExportPackage(assetPaths, packagePath, exportOpts);
}
static void ExportPackage()
{
string[] assets = new string[]
{
"Assets/Plugins",
"Assets/StreamingAssets",
"Assets/UXF"
};
DateTime dt = DateTime.Now;
string date = dt.ToString("yy_MM_dd");
if (!Directory.Exists("Package"))
{
Directory.CreateDirectory("Package");
}
string path = string.Format("Package/UXF_{0}.unitypackage", date);
ExportPackageOptions options = ExportPackageOptions.Recurse;
AssetDatabase.ExportPackage(assets, path, options);
}
static void ExportPackage()
{
string[] assets = new string[]
{
"Assets/Plugins",
"Assets/StreamingAssets",
"Assets/UXF"
};
if (!Directory.Exists("Package"))
{
Directory.CreateDirectory("Package");
}
string path = "Package/UXF.unitypackage";
ExportPackageOptions options = ExportPackageOptions.Recurse;
AssetDatabase.ExportPackage(assets, path, options);
}
public static void Export(PackageInfo package)
{
if (package == null)
{
Debug.LogError(string.Concat(name, "Package can't be null"));
return;
}
string readmePath = AssetDatabase.GetAssetPath(package.folder) + "/Readme.txt";
string readmeContent = string.Concat(openToken
, "\n", authorKey, " = ", package.author
, "\n", nameKey, " = ", package.name
, "\n", versionKey, " = ", package.Version
, "\n", closeToken, "\n\n"
, package.readme);
try
{
File.WriteAllText(readmePath, readmeContent);
}
catch (System.Exception e)
{
Debug.LogError(e);
}
AssetDatabase.ImportAsset(readmePath);
Directory.CreateDirectory(exportPath);
string packagePath = string.Concat(exportPath
, package.name
, " v", package.Version
, ".unitypackage");
const ExportPackageOptions exportOptions = ExportPackageOptions.Recurse | ExportPackageOptions.Interactive;
AssetDatabase.ExportPackage(AssetDatabase.GetAssetPath(package.folder), packagePath, exportOptions);
}
public static void ExportFiles()
{
var folders = Directory.GetDirectories(Application.dataPath + "/BUCK", "*.*");
const ExportPackageOptions exportFlags = ExportPackageOptions.Recurse;
foreach (var folder in folders)
{
var assetFiles = Directory.GetFiles(folder, "*.*", SearchOption.AllDirectories);
var assetExportLoc = Application.dataPath + "/../Builds/BUCK " + folder.Replace("\\", "/").Replace(Application.dataPath + "/BUCK/", string.Empty) + ".unitypackage";
for (var i = 0; i < assetFiles.Length; i++)
{
assetFiles[i] = "Assets/BUCK" + assetFiles[i].Replace("\\", "/").Replace(Application.dataPath + "/BUCK", string.Empty);
}
AssetDatabase.ExportPackage(assetFiles, assetExportLoc, exportFlags);
}
var files = Directory.GetFiles(Application.dataPath, "*.*", SearchOption.AllDirectories);
var exportLoc = Application.dataPath + "/../Builds/BUCK All Assets.unitypackage";
for (var i = 0; i < files.Length; i++)
{
files[i] = "Assets/BUCK" + files[i].Replace("\\", "/").Replace(Application.dataPath + "/BUCK", string.Empty);
}
AssetDatabase.ExportPackage(files, exportLoc, exportFlags);
}
static void ExportPackage()
{
string version;
if (File.Exists("Assets/UXF/VERSION.txt"))
{
version = File.ReadAllText("Assets/UXF/VERSION.txt");
}
else
{
version = "unknown";
}
string outName = string.Format("UXF.v{0}.unitypackage", version);
if (EditorUtility.DisplayDialog("Export Package", string.Format("Export package '{0}'?", outName), "Yes", "Cancel"))
{
string[] assets = new string[]
{
"Assets/StreamingAssets",
"Assets/UXF",
"Assets/WebGLTemplates"
};
if (!Directory.Exists("Package"))
{
Directory.CreateDirectory("Package");
}
string path = Path.Combine("Package", outName);
ExportPackageOptions options = ExportPackageOptions.Recurse;
AssetDatabase.ExportPackage(assets, path, options);
}
}
public static void ExportPackage(string[] assetPathNames, string fileName)
{
ExportPackageOptions flags = ExportPackageOptions.Default;
AssetDatabase.ExportPackage(assetPathNames, fileName, flags);
}
public static extern void ExportPackage(string[] assetPathNames, string fileName, [DefaultValue("ExportPackageOptions.Default")] ExportPackageOptions flags);
