void SetProjectSetting(Project project)
{
PlayerSettings.companyName = project.CompanyName;
PlayerSettings.productName = project.ProjectName;
Texture2D tx = AssetDatabase.LoadAssetAtPath <Texture2D>(project.IconName);///tx = ("Assets/ArtWork/app_icon_360");
int[] iconSize = PlayerSettings.GetIconSizesForTargetGroup(BuildTargetGroup.Android);
Texture2D[] textureArray = new Texture2D[iconSize.Length];
for (int i = 0; i < textureArray.Length; i++)
{
textureArray[i] = tx;
}
textureArray[0] = tx;
PlayerSettings.SetIconsForTargetGroup(BuildTargetGroup.Android, textureArray);
AssetDatabase.SaveAssets();
PlayerSettings.SetApplicationIdentifier(BuildTargetGroup.Android, project.PackageName);
//PlayerSettings.applicationIdentifier = project.PackageName;
PlayerSettings.bundleVersion = project.Version;
PlayerSettings.Android.bundleVersionCode = int.Parse(project.BundleVersionCode);
//PlayerSettings.Android.keystoreName = project.KeystorePath;
//PlayerSettings.Android.keyaliasName = project.KeyaliasName;
//PlayerSettings.Android.keystorePass = project.KeystorePass;
//PlayerSettings.Android.keyaliasPass = project.KeyaliasPass;
PlayerSettings.Android.minSdkVersion = AndroidSdkVersions.AndroidApiLevel18;
PlayerSettings.Android.targetSdkVersion = AndroidSdkVersions.AndroidApiLevel22;
AssetDatabase.Refresh();
AssetDatabase.SaveAssets();
}
private void Validate()
{
int[] sizes = PlayerSettings.GetIconSizesForTargetGroup(BuildIcons.TargetGroup, BuildIcons.IconKind);
if (BuildIcons.Icons.Length != sizes.Length)
{
Debug.LogError(string.Format("Icons length '{0}' is not equal target group sizes length '{1}'.", BuildIcons.Icons.Length, sizes.Length));
return;
}
for (int i = 0; i < BuildIcons.Icons.Length; i++)
{
Texture2D icon = BuildIcons.Icons[i];
if (icon != null)
{
if (icon.width != icon.height)
{
Debug.LogError(string.Format("Icon '{0}' width ({1}) and height ({2}) is not equal", icon.name, icon.width, icon.height));
}
if (sizes[i] != icon.width)
{
Debug.LogError(string.Format("Icon '{0}' size ({1}) is not equal to required size ({2})", icon.name, icon.width, sizes[i]));
}
}
}
}
static void SetIcons(string Icon_Path)//设置Icon
{
if (!File.Exists(Icon_Path))
{
Icon_Path = @"Assets\Icon.jpg";
if (!File.Exists(Icon_Path))
{
EditorUtility.DisplayDialog("错误!!!", "没有找到该项目Icon", "确定");
Pass = false;
}
}
string iconPrefixName = "Icon";
//获取所有的Icon尺寸
int[] iconSizes = PlayerSettings.GetIconSizesForTargetGroup(BuildTargetGroup.Android);
Texture2D[] texArray = new Texture2D[iconSizes.Length];
for (int i = 0; i < iconSizes.Length; ++i)
{
int iconSize = iconSizes[i];
//获得对应目录下的Icon，并转换成Texture2D
Texture2D tex2D = AssetDatabase.LoadAssetAtPath(string.Format(Icon_Path, iconPrefixName, iconSize),
typeof(Texture2D)) as Texture2D;
texArray[i] = tex2D;
}
//设置到PlayerSettings的各个Icon上
PlayerSettings.SetIconsForTargetGroup(BuildTargetGroup.Android, texArray);
AssetDatabase.SaveAssets();
}
public static void SetAppIcon(BuildTargetGroup group, Texture2D texture)
{
var count = PlayerSettings.GetIconSizesForTargetGroup(group).Length;
var textures = new List <Texture2D>();
for (int i = 0; i < count; i++)
{
textures.Add(texture);
}
PlayerSettings.SetIconsForTargetGroup(group, textures.ToArray());
}
/// <summary>
/// Icon設定
/// </summary>
private void UIAndroidIcon()
{
mShowSetInfo.AndroidSet.IconSetStatus = EditorGUILayout.ToggleLeft(SDBaseType.cUIName034, mShowSetInfo.AndroidSet.IconSetStatus);
if (!mShowSetInfo.AndroidSet.IconSetStatus)
{
return;
}
EditorGUILayout.Space();
EditorGUI.indentLevel++;
mShowSetInfo.AndroidSet.IconOverride = EditorGUILayout.ToggleLeft(SDBaseType.cUIName035, mShowSetInfo.AndroidSet.IconOverride);
if (mShowSetInfo.AndroidSet.IconOverride)
{
EditorGUI.indentLevel++;
int[] aAndroidIconTexts = PlayerSettings.GetIconSizesForTargetGroup(BuildTargetGroup.Android);
for (int i = 0; i < mUIUseImages.AndroidIcons.Length; i++)
{
string aPicSize = "";
if (i < aAndroidIconTexts.Length)
{
aPicSize = aAndroidIconTexts[i] + "x" + aAndroidIconTexts[i];
}
else
{
aPicSize = SDBaseType.cUIName036;
}
if (i < mShowSetInfo.AndroidSet.DefIcons.Length)
{
IconObjectSet(aPicSize, ref mUIUseImages.AndroidIcons[i], ref mShowSetInfo.AndroidSet.DefIcons[i]);
}
}
EditorGUI.indentLevel--;
}
// Icon設定中有個Enable Android Banner區域，暫時不做處理
// mEnableAndroidBanner = EditorGUILayout.ToggleLeft("Enable Android Banner", mEnableAndroidBanner);
// if(mEnableAndroidBanner) {
// EditorGUI.indentLevel++;
// mEAndroidBanner = EditorGUILayout.ObjectField("320x180", mEAndroidBanner, typeof(Texture2D), false) as Texture2D;
//
// EditorGUILayout.BeginHorizontal();
// EditorGUILayout.Space();
// EditorGUILayout.Space();
// EditorGUILayout.PrefixLabel("Path :");
// EditorGUILayout.LabelField("Tmp/Path");
// EditorGUILayout.EndHorizontal();
// EditorGUI.indentLevel--;
// }
EditorGUI.indentLevel--;
}
private static void SetPlatformIcons(MultiPlatformItem pPlatformItem)
{
var targetGroup = GetBuildTargetGroup(pPlatformItem);
var pIconsFoldPath = Application.dataPath + "/" + pPlatformItem.iconFolder;
if (!Directory.Exists(pIconsFoldPath))
{
Debug.LogError("Icon folder [ " + pPlatformItem.iconFolder + "] is not exist (图标文件夹不存在)!");
return;
}
var iconFilePaths = Directory.GetFiles(pIconsFoldPath, "*.png", SearchOption.AllDirectories);
if (iconFilePaths.Length <= 0)
{
Debug.LogError("There is no png icon image in (不存在png图标) [" + pPlatformItem.iconFolder + "]");
return;
}
var pIconTextureList = new List <Texture2D> ();
foreach (var pIconPath in iconFilePaths)
{
var assetPath = pIconPath.Substring(Application.dataPath.Length);
assetPath = "Assets" + assetPath;
var pIconTex = AssetDatabase.LoadAssetAtPath <Texture2D> (assetPath);
pIconTextureList.Add(pIconTex);
}
var pTextureSizes = PlayerSettings.GetIconSizesForTargetGroup(targetGroup);
var pTargetIconArray = new Texture2D[pTextureSizes.Length];
for (var i = 0; i < pTextureSizes.Length; i++)
{
pTargetIconArray [i] = null;
foreach (var pTex in pIconTextureList)
{
if (pTex.width == pTextureSizes [i])
{
pTargetIconArray [i] = pTex;
break;
}
}
}
PlayerSettings.SetIconsForTargetGroup(targetGroup, pTargetIconArray);
}
static void Build(Texture2D tex, string pre, string gamename)
{
PlayerSettings.productName = gamename;
PlayerSettings.applicationIdentifier = "com.lebo." + pre;
BuildTargetGroup tar = BuildTargetGroup.Android;
#if UNITY_ANDROID
tar = BuildTargetGroup.Android;
#elif UNITY_IOS
tar = BuildTargetGroup.iOS;
#endif
int[] sizelist = PlayerSettings.GetIconSizesForTargetGroup(tar);
Texture2D[] texs = new Texture2D[sizelist.Length];
for (int i = 0; i < sizelist.Length; i++)
{
texs[i] = tex;
}
#if UNITY_ANDROID
PlayerSettings.SetIconsForTargetGroup(BuildTargetGroup.Android, texs);
#elif UNITY_IOS
PlayerSettings.SetIconsForTargetGroup(BuildTargetGroup.iOS, texs);
#endif
PlayerSettings.defaultInterfaceOrientation = UIOrientation.AutoRotation;
PlayerSettings.allowedAutorotateToLandscapeLeft = true;
PlayerSettings.allowedAutorotateToLandscapeRight = true;
string bagname = "";
string path = "";
#if UNITY_ANDROID
bagname = "lebogaming_android_" + pre + ".apk";
path = Application.dataPath.Replace("Assets", "/Publish/");
#elif UNITY_IOS
bagname = "lebogaming_ios_" + pre;
path = Application.dataPath.Replace("Assets", "Publish/");
#endif
path += bagname;
Debug.Log("path = " + path);
BuildPlayerOptions op = new BuildPlayerOptions();
op.scenes = null;
op.locationPathName = path;
#if UNITY_ANDROID
op.target = BuildTarget.Android;
#elif UNITY_IOS
op.target = BuildTarget.iOS;
#endif
op.options = BuildOptions.None;
BuildPipeline.BuildPlayer(op);
}
/// <summary>
/// ICON設定
/// </summary>
private void UIIOSIcon()
{
mShowSetInfo.IOSSet.IconSetStatus = EditorGUILayout.ToggleLeft(SDBaseType.cUIName034, mShowSetInfo.IOSSet.IconSetStatus);
if (!mShowSetInfo.IOSSet.IconSetStatus)
{
return;
}
EditorGUILayout.Space();
EditorGUI.indentLevel++;
mShowSetInfo.IOSSet.IconOverride = EditorGUILayout.ToggleLeft(SDBaseType.cUIName035, mShowSetInfo.IOSSet.IconOverride);
if (mShowSetInfo.IOSSet.IconOverride)
{
EditorGUI.indentLevel++;
int[] aIosIconTexts = PlayerSettings.GetIconSizesForTargetGroup(BuildTargetGroup.iOS);
for (int i = 0; i < mUIUseImages.IosIcons.Length; i++)
{
string aPicSize = "";
if (i < aIosIconTexts.Length)
{
aPicSize = aIosIconTexts[i] + "x" + aIosIconTexts[i];
}
else
{
aPicSize = SDBaseType.cUIName036;
}
if (i == 9)
{
EditorGUILayout.LabelField(SDBaseType.cUIName070, EditorStyles.boldLabel);
EditorGUILayout.Space();
}
else if (i == 12)
{
EditorGUILayout.LabelField(SDBaseType.cUIName071, EditorStyles.boldLabel);
EditorGUILayout.Space();
}
if (i < mShowSetInfo.IOSSet.DefIcons.Length)
{
IconObjectSet(aPicSize, ref mUIUseImages.IosIcons[i], ref mShowSetInfo.IOSSet.DefIcons[i]);
}
}
EditorGUI.indentLevel--;
}
mShowSetInfo.IOSSet.PrerenderedIcon = SetToggleHor(SDBaseType.cUIName072, mShowSetInfo.IOSSet.PrerenderedIcon);
EditorGUI.indentLevel--;
}
private static void updateAndroidIcons(string _iconPath)
{
Texture2D icon = (Texture2D)AssetDatabase.LoadAssetAtPath(_iconPath, typeof(Texture2D));
if (null == icon)
{
return;
}
int iconCount = PlayerSettings.GetIconSizesForTargetGroup(BuildTargetGroup.Android).Length;
Texture2D[] icons = new Texture2D[iconCount];
for (int i = 0; i < iconCount; i++)
{
icons[i] = icon;
}
PlayerSettings.SetIconsForTargetGroup(BuildTargetGroup.Android, icons);
}
private static void ConfigureIcons(BuildConfig cfg)
{
int[] sizes = PlayerSettings.GetIconSizesForTargetGroup(cfg.BuildTargetGroup);
Texture2D[] icons = new Texture2D[sizes.Length];
Texture2D allIconTemplate = cfg.ICON;
if (allIconTemplate != null)
{
for (int i = 0; i < sizes.Length; i++)
{
icons[i] = allIconTemplate;
}
}
else
{
Debug.LogWarning("BuildDriver::ConfigureIcons - ICON not found.");
}
PlayerSettings.SetIconsForTargetGroup(cfg.BuildTargetGroup, icons);
}
public static void SetIconForTargetGroup(BuildTargetGroup platform, Texture2D icon)
{
int[] iconSizes = PlayerSettings.GetIconSizesForTargetGroup(platform);
Texture2D[] icons = new Texture2D[iconSizes.Length];
for (int i = 0; i < icons.Length; i++)
{
if (icon.width == iconSizes[i])
{
icons[i] = icon;
}
else
{
Texture2D scaledIcon = new Texture2D(icon.width, icon.height, icon.format, false);
Graphics.CopyTexture(icon, scaledIcon);
scaledIcon.Resize(iconSizes[i], iconSizes[i], icon.format, false);
scaledIcon.Apply();
icons[i] = scaledIcon;
}
}
PlayerSettings.SetIconsForTargetGroup(platform, icons);
}
/// <summary>
/// Attempt to use an <see cref="Texture2D"/> identified by <see cref="string"/> <paramref name="iconGuid"/> to
/// override the App Icon settings for <see cref="BuildTargetGroup"/> <paramref name="buildTargetGroup"/>.
/// </summary>
/// <param name="iconGuid"></param>
/// <param name="buildTargetGroup"></param>
private static void TrySetAppIcons(string iconGuid, BuildTargetGroup buildTargetGroup)
{
var iconPath = AssetDatabase.GUIDToAssetPath(iconGuid);
if (string.IsNullOrEmpty(iconPath))
{
Debug.LogWarning(CANNOT_FIND_APP_ICON);
}
else
{
var iconSizes = PlayerSettings.GetIconSizesForTargetGroup(buildTargetGroup);
var iconTexture = AssetDatabase.LoadAssetAtPath <Texture2D>(iconPath);
var newIconGroup = new Texture2D[iconSizes.Length];
for (var i = 0; i < newIconGroup.Length; i++)
{
newIconGroup[i] = iconTexture;
}
PlayerSettings.SetIconsForTargetGroup(buildTargetGroup, newIconGroup);
}
}
private void SetIconSettings(BuildTargetGroup buildTargetGroup)
{
if (iconFolder == null)
{
return;
}
// プラットフォームのアイコンサイズを取得。
var iconSizes = PlayerSettings.GetIconSizesForTargetGroup(buildTargetGroup);
var icons = new Texture2D[iconSizes.Length];
var folderPath = AssetDatabase.GetAssetPath(iconFolder);
var iconTextures = UnityEditorUtility.LoadAssetsInFolder <Texture2D>(folderPath);
for (var i = 0; i < iconSizes.Length; i++)
{
var size = iconSizes[i];
Texture2D texture = null;
foreach (var iconTexture in iconTextures)
{
var assetPath = AssetDatabase.GetAssetPath(iconTexture);
var assetName = Path.GetFileName(assetPath);
// icon_72x72.png.
if (assetName.Contains(string.Format("{0}x{1}", size, size)))
{
texture = iconTexture;
break;
}
}
icons[i] = texture;
}
PlayerSettings.SetIconsForTargetGroup(buildTargetGroup, icons);
}
public static void BuildAndroid()
{
string qudao = GetArgValue("qudao").ToLower();
string bundleId = GetArgValue("bundleId");
string iconname = GetArgValue("icon");
Texture2D icon = AssetDatabase.LoadAssetAtPath("Assets/logo/" + iconname + ".png", typeof(Texture2D)) as Texture2D;
int[] sizes = PlayerSettings.GetIconSizesForTargetGroup(BuildTargetGroup.Android);
Texture2D[] icons = new Texture2D[sizes.Length];
for (int i = 0; i < icons.Length; ++i)
{
icons[i] = icon;
}
PlayerSettings.SetIconsForTargetGroup(BuildTargetGroup.Android, icons);
PlayerSettings.applicationIdentifier = bundleId;
StreamReader st = new StreamReader("Assets/StreamingAssets/res/version.txt");
string version = st.ReadLine().Trim();
PlayerSettings.bundleVersion = version;
st.Close();
PlayerSettings.Android.bundleVersionCode = System.Int32.Parse(version.Replace(".", ""));
string keystoreName = "android";
string keystorePwd = "wqgame";
string keyaliasName = "android.keystore";
PlayerSettings.productName = "刀塔3";
PlayerSettings.Android.keystoreName = "../../../android/keystore/" + keystoreName + ".keystore";
PlayerSettings.Android.keystorePass = keystorePwd;
PlayerSettings.Android.keyaliasName = keyaliasName;
PlayerSettings.Android.keyaliasPass = keystorePwd;
PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android, "PLATFORM_ANDROID,PLATFORM_" + qudao.ToUpper());
BuildPipeline.BuildPlayer(GetLevels(), PackageName + ".apk", BuildTarget.Android, BuildOptions.None);
PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android, "");
}
private void Apply()
{
for (int i = 0; i < cdl.clientData.Count; i++)
{
if (cdl.clientData[i].platform == nowData.platform)
{
cdl.clientData[i] = nowData;
break;
}
}
PlayerSettings.productName = nowData.gameName;
PlayerSettings.applicationIdentifier = nowData.gameID;
PlayerSettings.bundleVersion = nowData.version;
BuildTargetGroup group = GetBuildGroupByTarget;
#if UNITY_STANDALONE
group = GetBuildGroupByTarget;
#elif UNITY_ANDROID
PlayerSettings.Android.keystorePass = "******";
PlayerSettings.Android.keyaliasPass = "******";
PlayerSettings.Android.targetSdkVersion = AndroidSdkVersions.AndroidApiLevel23;
// group = GetBuildGroupByTarget(BuildTarget.Android);
#elif UNITY_IPHONE
group = GetBuildGroupByTarget(BuildTarget.iOS);
PlayerSettings.SetArchitecture(group, 0);
PlayerSettings.stripEngineCode = false;
PlayerSettings.SetArchitecture(group, 1);
#endif
int[] iconSizes = PlayerSettings.GetIconSizesForTargetGroup(group);
Texture2D[] texture = new Texture2D[iconSizes.Length];
for (int i = 0; i < texture.Length; i++)
{
texture[i] = AssetDatabase.LoadAssetAtPath <Texture2D>(nowData.iconPath);
}
PlayerSettings.SetIconsForTargetGroup(group, texture);
AssetDatabase.Refresh();
Debug.Log("设置成功:" + nowData.gameName + "+" + nowData.gameID + "+" + nowData.version);
}
public override BuildState OnUpdate()
{
var tex = (Texture2D)AssetDatabase.LoadAssetAtPath(Path, typeof(Texture2D));
if (tex == null)
{
Debug.LogError("Icon Not Found : " + Path);
return(BuildState.Failure);
}
var count = PlayerSettings.GetIconSizesForTargetGroup(this.Group).Length;
var textures = new List <Texture2D>();
for (int i = 0; i < count; i++)
{
textures.Add(tex);
}
PlayerSettings.SetIconsForTargetGroup(this.Group, textures.ToArray());
return(BuildState.Success);
}
public static void BuildIOS()
{
string qudao = GetArgValue("qudao");
string bundleId = GetArgValue("bundleId");
string iconname = GetArgValue("icon");
string projectPath = GetArgValue("outpath");
Texture2D icon = AssetDatabase.LoadAssetAtPath("Assets/logo/" + iconname + ".png", typeof(Texture2D)) as Texture2D;
int[] sizes = PlayerSettings.GetIconSizesForTargetGroup(BuildTargetGroup.iOS);
Texture2D[] icons = new Texture2D[sizes.Length];
for (int i = 0; i < icons.Length; ++i)
{
icons[i] = icon;
}
PlayerSettings.productName = "刀塔3";
PlayerSettings.SetIconsForTargetGroup(BuildTargetGroup.iOS, icons);
PlayerSettings.applicationIdentifier = bundleId;
StreamReader st = new StreamReader("Assets/StreamingAssets/res/version.txt");
string bundleVersion = st.ReadLine().Trim();
if (qudao == "pp")
{
int index = bundleVersion.LastIndexOf('.');
bundleVersion = bundleVersion.Substring(0, index) + bundleVersion.Substring(index + 1);
PlayerSettings.bundleVersion = bundleVersion;
}
else
{
PlayerSettings.bundleVersion = bundleVersion;
}
st.Close();
PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS, "PLATFORM_IOS,PLATFORM_" + qudao.ToUpper());
BuildPipeline.BuildPlayer(GetLevels(), projectPath, BuildTarget.iOS, BuildOptions.AcceptExternalModificationsToPlayer | BuildOptions.SymlinkLibraries);
PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS, "");
}
/// <summary>
/// 设置安卓的spalshicon 可通用
/// </summary>
private static void SetAndroidSpalshIcon(string platformName, AppGameConfig gameCfg)
{
//先清理资源文件
FileUtils.CleanDirectory(UnityEngine.Application.dataPath + "/PlatformData/");
AssetDatabase.Refresh();
#region unity splash
#if UNITY_5_6_OR_NEWER
{
List <PlayerSettings.SplashScreenLogo> logoList = new List <PlayerSettings.SplashScreenLogo>();
string screenSourcePath = string.Format(Directory.GetParent(UnityEngine.Application.dataPath) + "/PlatformData/{0}/android/splash_screen/", platformName);//源目录文件夹
string screenTargetPath = string.Format(UnityEngine.Application.dataPath + "/PlatformData/{0}/android/splash_screen/", platformName);
//存在splash文件时,拷贝到unity
if (Directory.Exists(screenSourcePath))
{
if (Directory.Exists(screenTargetPath))
{
AssetBuilderCtrl.CleanDirectory(screenTargetPath);
}
Directory.CreateDirectory(screenTargetPath);
AssetBuilderCtrl.CopyDirectory(screenSourcePath, screenTargetPath);//拷贝文件夹资源
AssetDatabase.Refresh();
screenTargetPath = string.Format("Assets/PlatformData/{0}/android/splash_screen/", platformName);
}
if (Directory.Exists(screenTargetPath))
{
for (int i = 1; i <= 3; i++)
{
string logoPath = screenTargetPath + i + ".png";
if (!File.Exists(logoPath))
{
logoPath = screenTargetPath + i + ".jpg";
}
if (File.Exists(logoPath))
{
Sprite logoSp = (Sprite)AssetDatabase.LoadAssetAtPath(logoPath, typeof(Sprite));
if (logoSp == null)
{
TextureImporter import = AssetImporter.GetAtPath(logoPath) as TextureImporter;
import.textureType = TextureImporterType.Sprite;
import.spriteImportMode = SpriteImportMode.Single;
import.mipmapEnabled = false;
import.sRGBTexture = true;
import.alphaSource = TextureImporterAlphaSource.FromInput;
import.anisoLevel = 16;
AssetDatabase.ImportAsset(logoPath);
logoSp = (Sprite)AssetDatabase.LoadAssetAtPath(logoPath, typeof(Sprite));
}
if (logoSp != null)
{
PlayerSettings.SplashScreenLogo logo =
PlayerSettings.SplashScreenLogo.Create(2.5f, logoSp);
logoList.Add(logo);
}
}
}
PlayerSettings.SplashScreen.logos = logoList.ToArray();
PlayerSettings.SplashScreen.drawMode = PlayerSettings.SplashScreen.DrawMode.AllSequential;
PlayerSettings.SplashScreen.backgroundColor = Color.white;
PlayerSettings.SplashScreen.unityLogoStyle = PlayerSettings.SplashScreen.UnityLogoStyle.DarkOnLight;
PlayerSettings.SplashScreen.show = true;
PlayerSettings.SplashScreen.showUnityLogo = false;
}
else
{
PlayerSettings.SplashScreen.show = false;
PlayerSettings.SplashScreen.showUnityLogo = false;
}
// Directory.Delete(screenTargetPath);//设置完后删除？
}
#endif
#endregion
#region splash
{
string screenSourcePath = string.Format(Directory.GetParent(UnityEngine.Application.dataPath) + "/PlatformData/{0}/android/assets/splash/", platformName);//源目录文件夹
string screenTargetPath = string.Format(UnityEngine.Application.dataPath + "/PlatformData/{0}/android/assets/splash/", platformName);
//存在splash文件时,拷贝到unity
if (Directory.Exists(screenSourcePath))
{
if (Directory.Exists(screenTargetPath))
{
AssetBuilderCtrl.CleanDirectory(screenTargetPath);
}
Directory.CreateDirectory(screenTargetPath);
AssetBuilderCtrl.CopyDirectory(screenSourcePath, screenTargetPath);//拷贝文件夹资源
AssetDatabase.Refresh();
screenTargetPath = string.Format("Assets/PlatformData/{0}/android/assets/splash/", platformName);
}
int splashCount = 0;
for (int i = 1; i <= 3; i++)
{
string iconPath = string.Format("{0}{1}.png", screenTargetPath, i);
Texture2D tex2d = AssetDatabase.LoadAssetAtPath <Texture2D>(iconPath);
if (tex2d != null)
{
splashCount++;
PlayerSettings.showUnitySplashScreen = false;
#if UNITY_2017_1_OR_NEWER
PlayerSettings.virtualRealitySplashScreen = tex2d;
#endif
}
else
{
break;
}
}
AssetDatabase.Refresh();
gameCfg.Splash = splashCount;
}
PlayerSettings.showUnitySplashScreen = false;
#endregion
#region Set icon
{
string screenSourcePath = string.Format(Directory.GetParent(UnityEngine.Application.dataPath) + "/PlatformData/{0}/android/icon/", platformName);//源目录文件夹
string screenTargetPath = string.Format(UnityEngine.Application.dataPath + "/PlatformData/{0}/android/icon/", platformName);
if (Directory.Exists(screenSourcePath))
{
if (Directory.Exists(screenTargetPath))
{
AssetBuilderCtrl.CleanDirectory(screenTargetPath);
}
Directory.CreateDirectory(screenTargetPath);
AssetBuilderCtrl.CopyDirectory(screenSourcePath, screenTargetPath);//拷贝文件夹资源
AssetDatabase.Refresh();
}
screenTargetPath = string.Format("Assets/PlatformData/{0}/android/icon/", platformName);
int[] sizeList = PlayerSettings.GetIconSizesForTargetGroup(BuildTargetGroup.Android);
Texture2D[] icons = new Texture2D[sizeList.Length];
for (int i = 0; i < sizeList.Length; i++)
{
string iconPath = string.Format("{0}icon_{1}.png", screenTargetPath, sizeList[i]);
Texture2D textIcon = (Texture2D)AssetDatabase.LoadAssetAtPath(iconPath, typeof(Texture2D));
icons[i] = textIcon;
}
PlayerSettings.SetIconsForTargetGroup(BuildTargetGroup.Android, icons);
}
#endregion
}
public static void SetDefaultIcon()
{
if (GlobalToolConfigure.Current == null || GlobalToolConfigure.Current.SDK == null)
{
Debug.LogError("GlobalToolConfigure not found, Cannot set default icon");
return;
}
if (string.IsNullOrEmpty(GlobalToolConfigure.Current.SDK.DefaultIconFilter) || string.IsNullOrEmpty(GlobalToolConfigure.Current.SDK.DefaultIconFilterSearchPath))
{
Debug.LogError("GlobalToolConfigure -> DefaultIconFilter、DefaultIconFilterSearchPath is error, Cannot set default icon");
return;
}
Debug.Log("Starting set default icon");
string filter = GlobalToolConfigure.Current.SDK.DefaultIconFilter;
string filterSearchPath = BuildPipelineAsset.GetChannelFilterSearchPath(GlobalToolConfigure.Current.SDK.DefaultIconFilterSearchPath);
var folders = new List <string>()
{
filterSearchPath
};
string[] searchInFolders = folders.ToArray();
string[] assets = AssetDatabase.FindAssets(filter, searchInFolders);
if (assets == null || assets.Length == 0)
{
Debug.LogError(string.Format("Dir: {0} 下未找到匹配的资源, Icon设置失败", filterSearchPath));
return;
}
List <Texture2D> mTextures = new List <Texture2D>();
mTextures.Clear();
for (int i = 0; assets != null && i < assets.Length; i++)
{
string assetPath = AssetDatabase.GUIDToAssetPath(assets[i]);
if (assetPath == null)
{
continue;
}
Texture2D asset = AssetDatabase.LoadAssetAtPath <Texture2D>(assetPath);
if (asset == null)
{
continue;
}
mTextures.Add(asset);
}
BuildTarget buildTarget = EditorUserBuildSettings.activeBuildTarget;
BuildTargetGroup buildTargetGroup = BuildPipelineCommonTools.BuildUtils.GetBuildTargetGroup(buildTarget);
int[] iconSize = PlayerSettings.GetIconSizesForTargetGroup(buildTargetGroup);
Texture2D[] textureArray = new Texture2D[iconSize.Length];
for (int i = 0; i < textureArray.Length; i++)
{
textureArray[i] = mTextures[0];
}
PlayerSettings.SetIconsForTargetGroup(buildTargetGroup, textureArray);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
Debug.Log("Set default icon succeeded");
//MethodInfo getIconFormPlatform = typeof(PlayerSettings).GetMethod("GetIconsForPlatform", BindingFlags.NonPublic | BindingFlags.Static);
//MethodInfo getIconSizesForPlatform = typeof(PlayerSettings).GetMethod("GetIconSizesForPlatform", BindingFlags.NonPublic | BindingFlags.Static);
//MethodInfo setIconsForPlatform = typeof(PlayerSettings).GetMethod("SetIconsForPlatform", BindingFlags.NonPublic | BindingFlags.Static);
//Texture2D[] textureArray = (Texture2D[])getIconFormPlatform.Invoke(null, new object[] { string.Empty });
//var iconSizesForPlatform = (int[])getIconSizesForPlatform.Invoke(null, new object[] { string.Empty });
//if (textureArray.Length != iconSizesForPlatform.Length)
//{
// textureArray = new Texture2D[iconSizesForPlatform.Length];
// setIconsForPlatform.Invoke(null, new object[] { string.Empty, textureArray });
//}
//textureArray[0] = mTextures[0];
//setIconsForPlatform.Invoke(null, new object[] { string.Empty, textureArray });
//AssetDatabase.SaveAssets();
}
public static void ApplyPlayerSettings(ProjectBuildData data)
{
Type type = typeof(PlayerSettings);
var types = typeof(PlayerSettings).GetNestedTypes();
foreach (var nested in types)
{
if (!data.Settings.ContainsKey(nested.Name))
{
continue;
}
string val = data.Settings[nested.Name];
var reader = new LitJson.JsonReader(val);
while (reader.Read())
{
switch (reader.Token)
{
case LitJson.JsonToken.PropertyName:
{
string key = reader.Value.ToString();
reader.Read();
var info = nested.GetProperty(key);
if (info == null || !info.CanWrite)
{
Debug.LogWarning("ingore property:" + key);
continue;
}
if (info.PropertyType == typeof(string))
{
info.SetValue(null, reader.Value, null);
}
else if (info.PropertyType == typeof(bool))
{
info.SetValue(null, bool.Parse(reader.Value.ToString()), null);
}
else if (info.PropertyType == typeof(int))
{
info.SetValue(null, int.Parse(reader.Value.ToString()), null);
}
else if (info.PropertyType.IsEnum)
{
info.SetValue(null, Enum.Parse(info.PropertyType, reader.Value.ToString()), null);
}
else
{
Debug.LogWarning("unidentifiable property named:" + key + " type:" + info.PropertyType.Name);
}
break;
}
}
}
}
foreach (var col in data.Settings)
{
PropertyInfo info = type.GetProperty(col.Key);
if (info == null || !info.CanWrite)
{
Debug.LogWarning("ignore property:" + col.Key);
continue;
}
Debug.LogWarning("set property:" + col.Key);
if (info.PropertyType == typeof(string))
{
info.SetValue(null, col.Value, null);
}
else if (info.PropertyType == typeof(bool))
{
info.SetValue(null, bool.Parse(col.Value), null);
}
else if (info.PropertyType == typeof(int))
{
info.SetValue(null, int.Parse(col.Value), null);
}
else if (info.PropertyType.IsEnum)
{
info.SetValue(null, Enum.Parse(info.PropertyType, col.Value), null);
}
else
{
Debug.LogWarning("unidentifiable field named:" + col.Key + " type:" + info.PropertyType.Name);
}
}
if (data.Settings.ContainsKey("Icons"))
{
string icons = data.Settings["Icons"];
var iconsList = icons.Split(',');
var iconsTextureList = new List <Texture2D>();
foreach (var str in iconsList)
{
var texture = AssetDatabase.LoadAssetAtPath <Texture2D>(str);
iconsTextureList.Add(texture);
}
var group = GetBuildGroupByTarget(data.Target);
var iconSizes = PlayerSettings.GetIconSizesForTargetGroup(group);
if (iconSizes.Length > iconsTextureList.Count)
{
int count = iconSizes.Length - iconsTextureList.Count;
for (int i = 0; i < count; i++)
{
iconsTextureList.Add(null);
}
}
PlayerSettings.SetIconsForTargetGroup(group, iconsTextureList.ToArray());
}
ApplySelectedScene(data.Scenes);
if (data.DebugBuild)
{
EditorUserBuildSettings.development = data.DebugBuild;
EditorUserBuildSettings.connectProfiler = true;
EditorUserBuildSettings.allowDebugging = true;
}
else
{
EditorUserBuildSettings.development = false;
EditorUserBuildSettings.connectProfiler = false;
EditorUserBuildSettings.allowDebugging = false;
}
PlayerSettings.SetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup, data.SymbolDefine);
PlayerSettings.bundleVersion = data.Version;
AssetDatabase.Refresh();
}
//这里封装了一个简单的通用方法。
public static void BulidTarget(string name, string publicer, string ver, string target, bool isDebug)
{
string app_name = name + ver + publicer;
string target_dir = string.Empty;
string target_name = app_name + ".exe";
BuildTargetGroup targetGroup = BuildTargetGroup.Standalone;
BuildTarget buildTarget = BuildTarget.StandaloneWindows;
string applicationPath = Application.dataPath.Replace("/Assets", "");
target_dir = applicationPath + "/TargetWin";
if (target == "Android")
{
string x86Dir = Application.dataPath + "/Plugins/x86";
string x64Dir = Application.dataPath + "/Plugins/x86_64";
if (Directory.Exists(x86Dir))
{
Directory.Delete(x86Dir, true);
}
if (Directory.Exists(x64Dir))
{
Directory.Delete(x64Dir, true);
}
AssetDatabase.Refresh();
Packager.BuildAndroidResource();
target_dir = applicationPath + "/TargetAndroid";
target_name = app_name + ".apk";
targetGroup = BuildTargetGroup.Android;
buildTarget = BuildTarget.Android;
}
else if (target == "IOS")
{
target_dir = applicationPath + "/TargetIOS";
target_name = app_name;
targetGroup = BuildTargetGroup.iOS;
buildTarget = BuildTarget.iOS;
}
else
{
Packager.BuildWindowsResource();
}
//每次build删除之前的残留
if (Directory.Exists(target_dir))
{
if (File.Exists(target_name))
{
File.Delete(target_name);
}
}
else
{
Directory.CreateDirectory(target_dir);
}
// Player Setting
//
PlayerSettings.companyName = "HF";
//
PlayerSettings.productName = name;
//
PlayerSettings.GetIconSizesForTargetGroup(targetGroup);
//
//
PlayerSettings.defaultInterfaceOrientation = UIOrientation.LandscapeLeft;
PlayerSettings.allowedAutorotateToLandscapeLeft = true;
PlayerSettings.allowedAutorotateToLandscapeRight = true;
PlayerSettings.allowedAutorotateToPortrait = false;
PlayerSettings.allowedAutorotateToPortraitUpsideDown = false;
//
PlayerSettings.statusBarHidden = true;
//
PlayerSettings.apiCompatibilityLevel = ApiCompatibilityLevel.NET_2_0_Subset;
//
PlayerSettings.bundleVersion = ver;
//
PlayerSettings.forceSingleInstance = true;
// bug？
//PlayerSettings.gpuSkinning = true;
//
PlayerSettings.renderingPath = RenderingPath.Forward;
//
PlayerSettings.strippingLevel = StrippingLevel.Disabled;
//
PlayerSettings.stripUnusedMeshComponents = true;
string[] SCENES = FindEnabledEditorScenes();
BuildOptions options = BuildOptions.None;
if (isDebug)
{
EditorUserBuildSettings.development = true;
EditorUserBuildSettings.connectProfiler = true;
options |= BuildOptions.Development;
options |= BuildOptions.ConnectWithProfiler;
}
else
{
EditorUserBuildSettings.development = false;
EditorUserBuildSettings.connectProfiler = false;
}
//开始Build场景，等待吧～
GenericBuild(SCENES, target_dir + "/" + target_name, buildTarget, options);
// 反定义宏
PlayerSettings.SetScriptingDefineSymbolsForGroup(targetGroup, "");
}
