public static ControlTemplate GetBuildDoneImage(BuildInfo buildInfo, IEnumerable<ProjectItem> allProjects, out ControlTemplate stateImage)
{
if (buildInfo == null || buildInfo.BuildAction == null || buildInfo.BuildScope == null)
{
stateImage = null;
return VectorResources.TryGet(BuildActionResourcesUri, "StandBy");
}
if (allProjects == null)
throw new InvalidOperationException();
int errorProjectsCount = allProjects.Count(item => item.State.IsErrorState());
bool buildedProjectsSuccess = buildInfo.BuildedProjects.BuildWithoutErrors;
string stateKey;
if (buildInfo.BuildIsCancelled)
stateKey = "BuildCancelled";
else if (!buildedProjectsSuccess)
stateKey = "BuildError";
else if (buildedProjectsSuccess && errorProjectsCount == 0)
stateKey = "BuildDone";
else if (buildedProjectsSuccess && errorProjectsCount != 0)
stateKey = "BuildErrorDone";
else
throw new InvalidOperationException();
stateImage = VectorResources.TryGet(BuildStateResourcesUri, stateKey);
string actionKey = GetBuildActionResourceKey(buildInfo.BuildAction.Value);
return VectorResources.TryGet(BuildActionResourcesUri, actionKey);
}
protected override SequenceConvertInfo Convert(
ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo, ParameterExpression param)
{
var predicate = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var info = builder.ConvertSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]), predicate.Parameters[0]);
if (info != null)
{
info.Expression = methodCall.Transform(ex => ConvertMethod(methodCall, 0, info, predicate.Parameters[0], ex));
if (param != null)
{
if (param.Type != info.Parameter.Type)
param = Expression.Parameter(info.Parameter.Type, param.Name);
if (info.ExpressionsToReplace != null)
foreach (var path in info.ExpressionsToReplace)
{
path.Path = path.Path.Transform(e => e == info.Parameter ? param : e);
path.Expr = path.Expr.Transform(e => e == info.Parameter ? param : e);
}
}
info.Parameter = param;
return info;
}
return null;
}
public override void DrawGUI(Rect position, BuildInfo buildReportToDisplay)
{
if (!buildReportToDisplay.HasUsedAssets)
{
return;
}
// init variables to use
// --------------------------------------------------------------------------
BuildReportTool.FileFilterGroup fileFilterGroupToUse = buildReportToDisplay.FileFilters;
if (BuildReportTool.Options.ShouldUseConfiguredFileFilters())
{
fileFilterGroupToUse = _configuredFileFilterGroup;
}
BuildReportTool.AssetList listToDisplay = GetAssetListToDisplay(buildReportToDisplay);
//BuildReportTool.SizePart[] assetListToUse = listToDisplay.GetListToDisplay(fileFilterGroupToUse);
//
//if (assetListToUse == null || assetListToUse.Length == 0)
//{
// fileFilterGroupToUse.ForceSetSelectedFilterIdx(0);
//}
if (listToDisplay == null)
{
if (IsShowingUsedAssets)
{
Utility.DrawCentralMessage(position, "No \"Used Assets\" included in this build report.");
}
else if (IsShowingUnusedAssets)
{
Utility.DrawCentralMessage(position, "No \"Unused Assets\" included in this build report.");
}
return;
}
// gui
// --------------------------------------------------------------------------
GUILayout.Space(1);
DrawTopBar(position, buildReportToDisplay, fileFilterGroupToUse);
if (buildReportToDisplay.HasUsedAssets)
{
DrawAssetList(position, listToDisplay, fileFilterGroupToUse, BuildReportTool.Options.AssetListPaginationLength);
}
// status bar at bottom
// --------------------------------------------------------------------------
GUILayout.Space(20);
string selectedInfoLabel = string.Format("{0}{1}. {2}{3} ({4}%) Click on an asset's checkbox to include it in size calculation. Click on the filename to highlight it on your Project window.", Labels.SELECTED_QTY_LABEL, listToDisplay.GetSelectedCount().ToString("N0"), Labels.SELECTED_SIZE_LABEL, listToDisplay.GetReadableSizeOfSumSelection(), listToDisplay.GetPercentageOfSumSelection().ToString("N"));
GUI.Label(new Rect(0, position.height - 20, position.width, 20), selectedInfoLabel, BuildReportTool.Window.Settings.STATUS_BAR_LABEL_STYLE_NAME);
}
public override void DrawGUI(Rect position, BuildInfo buildReportToDisplay)
{
GUILayout.Space(2); // top padding for scrollbar
_assetListScrollPos = GUILayout.BeginScrollView(_assetListScrollPos);
GUILayout.Space(10); // top padding for content
GUILayout.BeginHorizontal();
GUILayout.Space(10); // extra left padding
DrawTotalSize(buildReportToDisplay);
GUILayout.Space(BuildReportTool.Window.Settings.CATEGORY_HORIZONTAL_SPACING);
GUILayout.BeginVertical();
DrawBuildSizes(buildReportToDisplay);
GUILayout.Space(BuildReportTool.Window.Settings.CATEGORY_VERTICAL_SPACING);
DrawDLLList(buildReportToDisplay);
GUILayout.EndVertical();
GUILayout.Space(20); // extra right padding
GUILayout.EndHorizontal();
GUILayout.EndScrollView();
}
public DocumentBuilder(
IEnumerable<Assembly> assemblies,
ImmutableArray<string> postProcessorNames,
string templateHash,
string intermediateFolder = null,
string commitFromSHA = null,
string commitToSHA = null)
{
Logger.LogVerbose("Loading plug-in...");
using (new LoggerPhaseScope("ImportPlugins", true))
{
var assemblyList = assemblies?.ToList();
_container = GetContainer(assemblyList);
_container.SatisfyImports(this);
_currentBuildInfo.CommitFromSHA = commitFromSHA;
_currentBuildInfo.CommitToSHA = commitToSHA;
if (intermediateFolder != null)
{
_currentBuildInfo.PluginHash = ComputePluginHash(assemblyList);
_currentBuildInfo.TemplateHash = templateHash;
_currentBuildInfo.DirectoryName = IncrementalUtility.CreateRandomDirectory(intermediateFolder);
}
}
Logger.LogInfo($"{Processors.Count()} plug-in(s) loaded.");
foreach (var processor in Processors)
{
Logger.LogVerbose($"\t{processor.Name} with build steps ({string.Join(", ", from bs in processor.BuildSteps orderby bs.BuildOrder select bs.Name)})");
}
_postProcessors = GetPostProcessor(postProcessorNames);
_intermediateFolder = intermediateFolder;
_lastBuildInfo = LoadLastBuildInfo();
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var query = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[1], new SqlQuery()));
var except = query.SqlQuery;
sequence = new SubQueryContext(sequence);
var sql = sequence.SqlQuery;
except.ParentSql = sql;
if (methodCall.Method.Name == "Except")
sql.Where.Not.Exists(except);
else
sql.Where.Exists(except);
var keys1 = sequence.ConvertToSql(null, 0, ConvertFlags.Key);
var keys2 = query. ConvertToSql(null, 0, ConvertFlags.Key);
if (keys1.Length != keys2.Length)
throw new InvalidOperationException();
for (var i = 0; i < keys1.Length; i++)
{
except.Where
.Expr(keys1[i].Sql)
.Equal
.Expr(keys2[i].Sql);
}
return sequence;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="buildInfo">Build Info</param>
public Build(BuildInfo buildInfo)
{
this.buildInfo = buildInfo;
sProjectDir = sProjectsDir + @"\project-" + buildInfo.project_id;
commands = new LinkedList<string>();
__output.Clear();
}
public bool IsSequence(ExpressionBuilder builder, BuildInfo buildInfo)
{
var expr = (ChangeTypeExpression)buildInfo.Expression;
var info = new BuildInfo(buildInfo, expr.Expression);
return GetBuilder(builder, info).IsSequence(builder, info);
}
/// <summary>
/// Get a new build
/// </summary>
/// <returns>BuildInfo object or null on error/no build</returns>
public static BuildInfo getBuild()
{
Console.WriteLine("* Checking for builds...");
string sPostBody = "token=" + Uri.EscapeDataString(Config.token);
string sResp = post(apiurl + "/builds/register.json", sPostBody);
try
{
if (!String.IsNullOrEmpty(sResp))
{
JsonObject obj = JsonObject.Parse(sResp);
if (obj != null)
{
BuildInfo info = new BuildInfo();
info.id = obj.Get<int>("id");
info.project_id = obj.Get<int>("project_id");
info.commands = obj.Get<string[]>("commands");
info.repo_url = obj.Get("repo_url");
info.reference = obj.Get("sha");
info.ref_name = obj.Get("ref");
return info;
}
}
else
{
Console.WriteLine("* Nothing");
}
}
catch (Exception)
{
Console.WriteLine("* Failed");
}
return null;
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
if (sequence.SelectQuery.Select.TakeValue != null || sequence.SelectQuery.Select.SkipValue != null)
sequence = new SubQueryContext(sequence);
var lambda = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var sparent = sequence.Parent;
var order = new ExpressionContext(buildInfo.Parent, sequence, lambda);
var body = lambda.Body.Unwrap();
var sql = builder.ConvertExpressions(order, body, ConvertFlags.Key);
builder.ReplaceParent(order, sparent);
if (!methodCall.Method.Name.StartsWith("Then"))
sequence.SelectQuery.OrderBy.Items.Clear();
foreach (var expr in sql)
{
var e = builder.ConvertSearchCondition(sequence, expr.Sql);
sequence.SelectQuery.OrderBy.Expr(e, methodCall.Method.Name.EndsWith("Descending"));
}
return sequence;
}
public static IncrementalBuildContext Create(DocumentBuildParameters parameters, BuildInfo cb, BuildInfo lb, string intermediateFolder)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (cb == null)
{
throw new ArgumentNullException(nameof(cb));
}
if (intermediateFolder == null)
{
throw new ArgumentNullException(nameof(intermediateFolder));
}
var baseDir = Path.Combine(intermediateFolder, cb.DirectoryName);
var lastBaseDir = lb != null ? Path.Combine(intermediateFolder, lb.DirectoryName) : null;
var lastBuildStartTime = lb?.BuildStartTime;
var canBuildInfoIncremental = CanBuildInfoIncremental(cb, lb);
var lbv = lb?.Versions?.SingleOrDefault(v => v.VersionName == parameters.VersionName);
var cbv = new BuildVersionInfo
{
VersionName = parameters.VersionName,
ConfigHash = ComputeConfigHash(parameters),
AttributesFile = IncrementalUtility.CreateRandomFileName(baseDir),
DependencyFile = IncrementalUtility.CreateRandomFileName(baseDir),
ManifestFile = IncrementalUtility.CreateRandomFileName(baseDir),
XRefSpecMapFile = IncrementalUtility.CreateRandomFileName(baseDir),
BuildMessageFile = IncrementalUtility.CreateRandomFileName(baseDir),
Attributes = ComputeFileAttributes(parameters, lbv?.Dependency),
Dependency = new DependencyGraph(),
};
cb.Versions.Add(cbv);
var context = new IncrementalBuildContext(baseDir, lastBaseDir, lastBuildStartTime, canBuildInfoIncremental, parameters, cbv, lbv);
return context;
}
public DependencyBuildInfo(BuildInfo buildInfo, bool upgradeStableVersions)
{
BuildInfo = buildInfo;
UpgradeStableVersions = upgradeStableVersions;
Packages = buildInfo.LatestPackages
.Select(pair => new PackageIdentity(pair.Key, new NuGetVersion(pair.Value)))
.ToArray();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="buildInfo">Build Info</param>
public Build(BuildInfo buildInfo)
{
this.buildInfo = buildInfo;
sProjectDir = sProjectsDir + @"\project-" + buildInfo.project_id;
commands = new LinkedList<string>();
outputList = new ConcurrentQueue<string>();
completed = false;
}
public override void RefreshData(BuildInfo buildReport)
{
const string README_FILENAME = "README.txt";
_readmeContents = BuildReportTool.Util.GetPackageFileContents(README_FILENAME);
const string CHANGELOG_FILENAME = "VERSION.txt";
_changelogContents = BuildReportTool.Util.GetPackageFileContents(CHANGELOG_FILENAME);
}
public void Initialize(BuildInfo buildInfo)
{
Info = buildInfo;
nameLabel.text = buildInfo.name;
healthLabel.text = buildInfo.stats.health.ToString();
shieldLabel.text = buildInfo.stats.shield.ToString();
speedLabel.text = buildInfo.stats.speed.ToString();
damageLabel.text = buildInfo.stats.damage.ToString();
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var condition = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var result = builder.BuildWhere(buildInfo.Parent, sequence, condition, true);
result.SetAlias(condition.Parameters[0].Name);
return result;
}
protected override int? GetValue(DTE dte, BuildInfo buildContext)
{
try
{
return buildContext.BuildedProjects.BuildErrorCount;
}
catch (NullReferenceException)
{
return null;
}
}
public static ControlTemplate GetBuildBeginImage(BuildInfo buildInfo)
{
vsBuildAction? buildAction = buildInfo.BuildAction;
vsBuildScope? buildScope = buildInfo.BuildScope;
if (buildAction == null || buildScope == null)
return null;
string actionKey = GetBuildActionResourceKey(buildAction.Value);
return VectorResources.TryGet(BuildActionResourcesUri, actionKey);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var sql = sequence.SqlQuery;
if (sql.Select.TakeValue != null || sql.Select.SkipValue != null)
sequence = new SubQueryContext(sequence);
sequence.SqlQuery.Select.IsDistinct = true;
return sequence;
}
/// <summary>
/// The ship is built by having all of its parts fly together.
/// </summary>
/// <param name="buildInfo">Ship instructions.</param>
/// <param name="buildSize">Size of the grid.</param>
/// <param name="transform">Ship transforms.</param>
/// <param name="maxTime">How long the building process can take.</param>
/// <param name="finishedAction">Method to call when completed.</param>
public static IEnumerator Join(BuildInfo buildInfo, int buildSize, Transform transform, float maxTime, Action<BuildFinishedArgs> finishedAction = null)
{
var pieces = new List<BuildCUBE>();
const float minDist = 100f;
const float maxDist = 250f;
Vector3 halfGrid = Vector3.one * (buildSize / 2f - 1f);
Vector3 pivotOffset = -Vector3.one / 2f;
float speed = maxDist / maxTime;
foreach (var piece in buildInfo.partList)
{
CUBE cube = GameResources.CreateCUBE(piece.Key);
cube.transform.parent = transform;
Material[] materials = new Material[cube.renderer.materials.Length];
materials.SetAll(material);
cube.renderer.materials = materials;
cube.transform.localPosition = piece.Value.position.normalized * Random.Range(minDist, maxDist);
cube.transform.localPosition = Quaternion.Euler(Random.Range(0, 360), Random.Range(0, 360), Random.Range(0, 360)) * cube.transform.localPosition;
cube.transform.localEulerAngles = piece.Value.rotation;
if (piece.Value.weaponMap != -1)
{
((Weapon)cube.GetComponent(typeof(Weapon))).index = piece.Value.weaponMap;
}
if (piece.Value.augmentationMap != -1)
{
((Augmentation)cube.GetComponent(typeof(Augmentation))).index = piece.Value.augmentationMap;
}
((ColorVertices)cube.GetComponent(typeof(ColorVertices))).Bake(piece.Value.colors);
pieces.Add(new BuildCUBE(cube.transform, piece.Value.position - halfGrid + Utility.RotateVector(pivotOffset, Quaternion.Euler(piece.Value.rotation)), speed));
}
float time = maxTime;
while (time > 0f)
{
foreach (BuildCUBE piece in pieces)
{
piece.Update(Time.deltaTime);
}
time -= Time.deltaTime;
yield return null;
}
if (finishedAction != null)
{
finishedAction(new BuildFinishedArgs(transform.gameObject, buildInfo.stats, buildInfo.trimColor));
}
}
public void BuildInfoConstructorTest1()
{
BuildInfo target = new BuildInfo();
Assert.IsNotNull( target );
Assert.AreEqual( "231974", target.ApplyID );
Assert.AreEqual( string.Empty, target.ProductVerion );
Assert.AreEqual( "|AppID=231974|TaskNumber=0|ReleaseNumber=U100|VersionNumber=|", target.BuildLog );
Assert.AreEqual( "duany", target.Owner );
Assert.AreEqual( string.Empty, target.FixName );
Assert.AreEqual( "V4.0", target.BuildFrameworkVersion );
Assert.AreEqual( "2013-01-31T03:42:53.1880458+08:00", target.BuildTime );
}
public static string GetBuildBeginExtraMessage(
BuildInfo buildInfo,
BuildMessagesSettings labelsSettings)
{
if (buildInfo == null
|| buildInfo.BuildStartTime == null
|| !labelsSettings.ShowExtraMessage
|| labelsSettings.ExtraMessageDelay < 0)
{
return string.Empty;
}
TimeSpan timeSpan = DateTime.Now.Subtract(buildInfo.BuildStartTime.Value);
if (timeSpan.TotalSeconds > labelsSettings.ExtraMessageDelay)
{
string extraTimePartString;
switch (labelsSettings.ExtraMessageFormat)
{
case BuildExtraMessageFormat.Custom:
try
{
extraTimePartString = timeSpan.ToString(labelsSettings.TimeSpanFormat);
}
catch (FormatException)
{
extraTimePartString = Resources.InvalidTimeStringFormat;
}
break;
case BuildExtraMessageFormat.TotalSeconds:
extraTimePartString = string.Format("{0}", Math.Truncate(timeSpan.TotalSeconds));
break;
case BuildExtraMessageFormat.TotalMinutes:
extraTimePartString = string.Format("{0}", Math.Truncate(timeSpan.TotalMinutes));
break;
case BuildExtraMessageFormat.TotalMinutesWithSeconds:
extraTimePartString = string.Format("{0:00}:{1:00}", Math.Truncate(timeSpan.TotalMinutes), timeSpan.Seconds);
break;
default:
throw new ArgumentOutOfRangeException();
}
string extraString = string.Format(labelsSettings.ExtraMessageStringFormat, extraTimePartString);
return extraString;
}
return string.Empty;
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var table = (TableBuilder.TableContext)sequence;
var selector = (LambdaExpression)methodCall.Arguments[1].Unwrap();
if (table.SqlTable.LoadWith == null)
table.SqlTable.LoadWith = new List<MemberInfo[]>();
table.SqlTable.LoadWith.Add(GetAssosiations(builder, selector.Body.Unwrap()).ToArray());
return sequence;
}
public override IBuildContext GetContext(Expression expression, int level, BuildInfo buildInfo)
{
if (ReferenceEquals(expression, Lambda.Parameters[0]))
return Sequence.GetContext(null, 0, buildInfo);
switch (expression.NodeType)
{
case ExpressionType.Constant :
case ExpressionType.New :
case ExpressionType.MemberInit : return null;
}
return Sequence.GetContext(expression, level + 1, buildInfo);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var table = (TableBuilder.TableContext)sequence;
var value = (string)((ConstantExpression)methodCall.Arguments[1]).Value;
switch (methodCall.Method.Name)
{
case "TableName" : table.SqlTable.PhysicalName = value; break;
case "DatabaseName" : table.SqlTable.Database = value; break;
case "OwnerName" : table.SqlTable.Owner = value; break;
}
return sequence;
}
public void SaveToCache(IEnumerable<string> inputProjects, IDictionary<string, List<string>> containedFiles, DateTime triggeredTime, string outputFolder, IList<string> fileRelativePaths)
{
var key = inputProjects.GetNormalizedFullPathKey();
DateTime completeTime = DateTime.UtcNow;
BuildInfo info = new BuildInfo
{
InputFilesKey = key,
ContainedFiles = containedFiles,
TriggeredUtcTime = triggeredTime,
CompleteUtcTime = completeTime,
OutputFolder = outputFolder.ToNormalizedFullPath(),
RelatvieOutputFiles = fileRelativePaths.GetNormalizedPathList(),
BuildAssembly = AssemblyName,
};
this.SaveConfig(key, info);
}
public DependencyBuildInfo(
BuildInfo buildInfo,
bool upgradeStableVersions,
IEnumerable<string> disabledPackages)
{
BuildInfo = buildInfo;
UpgradeStableVersions = upgradeStableVersions;
RawPackages = buildInfo.LatestPackages
.Where(pair => !disabledPackages.Contains(pair.Key))
.ToDictionary(pair => pair.Key, pair => pair.Value);
Packages = RawPackages
.Select(pair => new PackageIdentity(pair.Key, new NuGetVersion(pair.Value)))
.ToArray();
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence1 = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var sequence2 = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[1], new SqlQuery()));
var union = new SqlQuery.Union(sequence2.SqlQuery, methodCall.Method.Name == "Concat");
var sq = sequence1 as SubQueryContext;
if (sq == null || sq.Union != null || !sq.SqlQuery.IsSimple)
sq = new SubQueryContext(sequence1);
sq.SubQuery.SqlQuery.Unions.Add(union);
sq.Union = sequence2;
return sq;
}
public void SaveToCache(IEnumerable<string> inputProjects, IDictionary<string, List<string>> containedFiles, DateTime triggeredTime, string outputFolder, IList<string> fileRelativePaths, bool shouldSkipMarkup)
{
var key = TypeForwardedToStringExtension.GetNormalizedFullPathKey(inputProjects);
DateTime completeTime = DateTime.UtcNow;
BuildInfo info = new BuildInfo
{
InputFilesKey = key,
ContainedFiles = containedFiles,
TriggeredUtcTime = triggeredTime,
CompleteUtcTime = completeTime,
OutputFolder = TypeForwardedToStringExtension.ToNormalizedFullPath(outputFolder),
RelatvieOutputFiles = TypeForwardedToStringExtension.GetNormalizedPathList(fileRelativePaths),
BuildAssembly = AssemblyName,
ShouldSkipMarkup = shouldSkipMarkup
};
this.SaveConfig(key, info);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var table = (TableBuilder.TableContext)sequence;
var value = (string)((ConstantExpression)methodCall.Arguments[1]).Value;
table.SqlTable.SqlTableType = SqlTableType.Expression;
table.SqlTable.TableArguments = new ISqlExpression[0];
switch (methodCall.Method.Name)
{
case "With" : table.SqlTable.Name = "{{0}} {{1}} WITH ({0})".Args(value); break;
case "WithTableExpression" : table.SqlTable.Name = value; break;
}
return sequence;
}
void DrawRuntimeSettings(BuildInfo buildReportToDisplay, UnityBuildSettings settings)
{
DrawSettingsGroupTitle("Runtime Settings");
if (IsShowingiOSSettings)
{
DrawSetting("Hide status bar:", settings.MobileHideStatusBar);
DrawSetting("Status bar style:", settings.iOSStatusBarStyle);
DrawSetting("Accelerometer frequency:", settings.MobileAccelerometerFrequency);
DrawSetting("Requires persistent Wi-Fi:", settings.iOSRequiresPersistentWiFi);
if (UnityMajorVersionUsedIsAtMost(4, buildReportToDisplay.UnityVersion))
{
DrawSetting("Exit on suspend:", settings.iOSExitOnSuspend);
}
if (UnityMajorVersionUsedIsAtLeast(5, buildReportToDisplay.UnityVersion))
{
DrawSetting("App-in-background behavior:", settings.iOSAppInBackgroundBehavior);
}
DrawSetting("Activity indicator on loading:", settings.iOSShowProgressBarInLoadingScreen);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingAndroidSettings)
{
DrawSetting("Hide status bar:", settings.MobileHideStatusBar);
DrawSetting("Accelerometer frequency:", settings.MobileAccelerometerFrequency);
DrawSetting("Activity indicator on loading:", settings.AndroidShowProgressBarInLoadingScreen);
DrawSetting("Splash screen scale:", settings.AndroidSplashScreenScaleMode);
DrawSetting("Preferred install location:", settings.AndroidPreferredInstallLocation);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
if (!IsShowingiOSSettings && !IsShowingAndroidSettings && IsShowingMobileSettings) // any mobile except iOS, Android
{
DrawSetting("Hide status bar:", settings.MobileHideStatusBar);
DrawSetting("Accelerometer frequency:", settings.MobileAccelerometerFrequency);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
if (IsShowingXbox360Settings)
{
DrawSetting("Enable avatar:", settings.Xbox360EnableAvatar);
DrawSetting("Enable Kinect:", settings.Xbox360EnableKinect);
DrawSetting("Enable Kinect auto-tracking:", settings.Xbox360EnableKinectAutoTracking);
DrawSetting("Deploy Kinect resources:", settings.Xbox360DeployKinectResources);
DrawSetting("Deploy Kinect head orientation:", settings.Xbox360DeployKinectHeadOrientation);
DrawSetting("Deploy Kinect head position:", settings.Xbox360DeployKinectHeadPosition);
DrawSetting("Enable speech:", settings.Xbox360EnableSpeech);
DrawSetting("Speech DB:", settings.Xbox360SpeechDB);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingBlackberrySettings)
{
DrawSetting("Has camera permissions:", settings.BlackBerryHasCamPermissions);
DrawSetting("Has microphone permissions:", settings.BlackBerryHasMicPermissions);
DrawSetting("Has GPS permissions:", settings.BlackBerryHasGpsPermissions);
DrawSetting("Has ID permissions:", settings.BlackBerryHasIdPermissions);
DrawSetting("Has shared permissions:", settings.BlackBerryHasSharedPermissions);
}
if (IsShowingStandaloneSettings || IsShowingWebPlayerSettings || IsShowingBlackberrySettings)
{
DrawSetting("Run in background:", settings.RunInBackground);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
}
public bool TryDetectAny(IReadOnlyDictionary <string, string> buildKeyValues, out BuildInfo buildInfo)
{
return(this.TryDetectAdvancedInstaller(buildKeyValues, out buildInfo) ||
this.TryDetectVisualStudio(buildKeyValues, out buildInfo) ||
this.TryDetectRayPack(buildKeyValues, out buildInfo) ||
this.TryDetectMsixHero(buildKeyValues, out buildInfo));
}
public void ShowPanel(BuildInfo buildInfo)
{
currentEditBuildInfo = buildInfo;
InputField.text = currentEditBuildInfo.BuildName;
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var collectionSelector = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var resultSelector = (LambdaExpression)methodCall.Arguments[2].Unwrap();
if (!sequence.SelectQuery.GroupBy.IsEmpty)
{
sequence = new SubQueryContext(sequence);
}
var context = new SelectManyContext(buildInfo.Parent, collectionSelector, sequence);
var expr = collectionSelector.Body.Unwrap();
var collectionInfo = new BuildInfo(context, expr, new SelectQuery());
var collection = builder.BuildSequence(collectionInfo);
var leftJoin = collection is DefaultIfEmptyBuilder.DefaultIfEmptyContext;
var sql = collection.SelectQuery;
var sequenceTables = new HashSet <ISqlTableSource>(sequence.SelectQuery.From.Tables[0].GetTables());
var newQuery = null != new QueryVisitor().Find(sql, e => e == collectionInfo.SelectQuery);
var crossApply = null != new QueryVisitor().Find(sql, e =>
e.ElementType == QueryElementType.TableSource && sequenceTables.Contains((ISqlTableSource)e) ||
e.ElementType == QueryElementType.SqlField && sequenceTables.Contains(((SqlField)e).Table) ||
e.ElementType == QueryElementType.Column && sequenceTables.Contains(((SelectQuery.Column)e).Parent));
if (collection is JoinBuilder.GroupJoinSubQueryContext)
{
var groupJoin = ((JoinBuilder.GroupJoinSubQueryContext)collection).GroupJoin;
groupJoin.SelectQuery.From.Tables[0].Joins[0].JoinType = SelectQuery.JoinType.Inner;
groupJoin.SelectQuery.From.Tables[0].Joins[0].IsWeak = false;
}
if (!newQuery)
{
context.Collection = new SubQueryContext(collection, sequence.SelectQuery, false);
return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context));
}
if (!crossApply)
{
if (!leftJoin)
{
context.Collection = new SubQueryContext(collection, sequence.SelectQuery, true);
return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context));
}
else
{
var join = SelectQuery.OuterApply(sql);
sequence.SelectQuery.From.Tables[0].Joins.Add(join.JoinedTable);
context.Collection = new SubQueryContext(collection, sequence.SelectQuery, false);
return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context));
}
}
if (collection is TableBuilder.TableContext)
{
var table = (TableBuilder.TableContext)collection;
var join = table.SqlTable.TableArguments != null && table.SqlTable.TableArguments.Length > 0 ?
(leftJoin ? SelectQuery.OuterApply(sql) : SelectQuery.CrossApply(sql)) :
(leftJoin ? SelectQuery.LeftJoin(sql) : SelectQuery.InnerJoin(sql));
join.JoinedTable.Condition.Conditions.AddRange(sql.Where.SearchCondition.Conditions);
join.JoinedTable.CanConvertApply = false;
sql.Where.SearchCondition.Conditions.Clear();
var collectionParent = collection.Parent as TableBuilder.TableContext;
// Association.
//
if (collectionParent != null && collectionInfo.IsAssociationBuilt)
{
var ts = (SelectQuery.TableSource) new QueryVisitor().Find(sequence.SelectQuery.From, e =>
{
if (e.ElementType == QueryElementType.TableSource)
{
var t = (SelectQuery.TableSource)e;
return(t.Source == collectionParent.SqlTable);
}
return(false);
});
ts.Joins.Add(join.JoinedTable);
}
else
{
sequence.SelectQuery.From.Tables[0].Joins.Add(join.JoinedTable);
}
context.Collection = new SubQueryContext(collection, sequence.SelectQuery, false);
return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context));
}
else
{
var join = leftJoin ? SelectQuery.OuterApply(sql) : SelectQuery.CrossApply(sql);
sequence.SelectQuery.From.Tables[0].Joins.Add(join.JoinedTable);
context.Collection = new SubQueryContext(collection, sequence.SelectQuery, false);
return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context));
}
}
public bool TryDetectAdvancedInstaller(IReadOnlyDictionary <string, string> buildValues, out BuildInfo buildInfo)
{
buildInfo = null;
if (buildValues == null || !buildValues.Any())
{
return(false);
}
if (!buildValues.TryGetValue("AdvancedInstaller", out var advInst))
{
return(false);
}
buildValues.TryGetValue("ProjectLicenseType", out var projLic);
buildInfo = new BuildInfo
{
ProductLicense = projLic,
ProductName = "Advanced Installer",
ProductVersion = advInst
};
if (buildValues.TryGetValue("OperatingSystem", out var os))
{
var win10Version = WindowsNames.GetOperatingSystemFromNameAndVersion(os);
buildInfo.OperatingSystem = win10Version.ToString();
}
return(true);
}
public override void RefreshData(BuildInfo buildReport)
{
_selectedSettingsIdxFromDropdownBox = UnityBuildSettingsUtility.GetIdxFromBuildReportValues(buildReport);
}
public bool TryDetectRayPack(IReadOnlyDictionary <string, string> buildValues, out BuildInfo buildInfo)
{
buildInfo = null;
if (buildValues == null || !buildValues.Any())
{
// Detect RayPack by taking a look at the metadata of PsfLauncher.
// This is a fallback in case there are no other build values.
const string fileLauncher = "PsfLauncher.exe";
if (!fileReader.FileExists(fileLauncher))
{
return(false);
}
using (var launcher = this.fileReader.GetFile(fileLauncher))
{
FileVersionInfo fileVersionInfo;
if (launcher is FileStream fileStream)
{
fileVersionInfo = FileVersionInfo.GetVersionInfo(fileStream.Name);
}
else
{
var tempFilePath = Path.GetTempFileName();
try
{
using (var fs = File.OpenWrite(tempFilePath))
{
launcher.CopyTo(fs);
fs.Flush();
}
fileVersionInfo = FileVersionInfo.GetVersionInfo(tempFilePath);
}
finally
{
File.Delete(tempFilePath);
}
}
if (fileVersionInfo.ProductName != null && fileVersionInfo.ProductName.StartsWith("Raynet", StringComparison.OrdinalIgnoreCase))
{
var pv = fileVersionInfo.ProductVersion;
buildInfo = new BuildInfo
{
ProductName = "RayPack " + Version.Parse(pv).ToString(2),
ProductVersion = fileVersionInfo.ProductVersion
};
return(true);
}
}
}
else
{
// Detect RayPack 6.2 which uses build meta data like this:
// <build:Item Name="OperatingSystem" Version="6.2.9200.0" /><build:Item Name="Raynet.RaySuite.Common.Appx" Version="6.2.5306.1168" /></build:Metadata>
if (!buildValues.TryGetValue("Raynet.RaySuite.Common.Appx", out var rayPack))
{
return(false);
}
if (Version.TryParse(rayPack, out var parsedVersion))
{
buildInfo = new BuildInfo
{
ProductName = $"RayPack {parsedVersion.Major}.{parsedVersion.Minor}",
ProductVersion = $"(MSIX builder v{parsedVersion})"
};
}
else
{
buildInfo = new BuildInfo
{
ProductName = "RayPack",
ProductVersion = $"(MSIX builder v{rayPack})"
};
}
if (buildValues.TryGetValue("OperatingSystem", out var os))
{
var win10Version = WindowsNames.GetOperatingSystemFromNameAndVersion(os);
buildInfo.OperatingSystem = win10Version.ToString();
}
return(true);
}
return(false);
}
protected override bool CanBuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
return
(methodCall.IsQueryable("SelectMany") &&
methodCall.Arguments.Count == 3 &&
((LambdaExpression)methodCall.Arguments[1].Unwrap()).Parameters.Count == 1);
}
public override void DrawGUI(Rect position, BuildInfo buildReportToDisplay, AssetDependencies assetDependencies, out bool requestRepaint)
{
if (buildReportToDisplay == null)
{
requestRepaint = false;
return;
}
GUILayout.Space(2); // top padding for scrollbar
_scrollPos = GUILayout.BeginScrollView(_scrollPos);
GUILayout.BeginHorizontal();
GUILayout.Space(10); // extra left padding
GUILayout.BeginVertical();
GUILayout.Space(10); // top padding
// report title
GUILayout.Label(buildReportToDisplay.SuitableTitle, BuildReportTool.Window.Settings.MAIN_TITLE_STYLE_NAME);
GUILayout.Space(10);
// two-column layout
GUILayout.BeginVertical();
GUILayout.BeginHorizontal();
// 1st column
GUILayout.BeginVertical(GUILayout.MaxWidth(350));
GUILayout.Label(Labels.TIME_OF_BUILD_LABEL, BuildReportTool.Window.Settings.INFO_TITLE_STYLE_NAME);
GUILayout.Label(buildReportToDisplay.GetTimeReadable(), BuildReportTool.Window.Settings.INFO_SUBTITLE_STYLE_NAME);
GUILayout.Label("Report generation took:", BuildReportTool.Window.Settings.INFO_TITLE_STYLE_NAME);
GUILayout.Label(buildReportToDisplay.ReportGenerationTime.ToString(), BuildReportTool.Window.Settings.INFO_SUBTITLE_STYLE_NAME);
if (!string.IsNullOrEmpty(buildReportToDisplay.TotalBuildSize) && !string.IsNullOrEmpty(buildReportToDisplay.BuildFilePath))
{
GUILayout.BeginVertical();
GUILayout.Label(Labels.BUILD_TOTAL_SIZE_LABEL, BuildReportTool.Window.Settings.INFO_TITLE_STYLE_NAME);
GUILayout.Label(BuildReportTool.Util.GetBuildSizePathDescription(buildReportToDisplay),
BuildReportTool.Window.Settings.TINY_HELP_STYLE_NAME);
GUILayout.Label(buildReportToDisplay.TotalBuildSize, BuildReportTool.Window.Settings.BIG_NUMBER_STYLE_NAME);
GUILayout.EndVertical();
}
GUILayout.Space(20);
if (assetDependencies != null)
{
if (!string.IsNullOrEmpty(assetDependencies.SavedPath))
{
GUILayout.Label("Asset Dependencies file used:",
BuildReportTool.Window.Settings.INFO_TITLE_STYLE_NAME);
GUILayout.Label(assetDependencies.SavedPath,
BuildReportTool.Window.Settings.INFO_SUBTITLE_STYLE_NAME);
GUILayout.Space(20);
}
}
string emphasisColor = "black";
if (EditorGUIUtility.isProSkin || BRT_BuildReportWindow.FORCE_USE_DARK_SKIN)
{
emphasisColor = "white";
}
string largestAssetCategoryLabel = string.Format(
"<color={0}><size=20><b>{1}</b></size></color> are the largest,\ntaking up <color={0}><size=20><b>{2}%</b></size></color> of the build{3}",
emphasisColor, buildReportToDisplay.BuildSizes[1].Name, buildReportToDisplay.BuildSizes[1].Percentage.ToString(CultureInfo.InvariantCulture),
(!buildReportToDisplay.HasStreamingAssets
? "\n<size=12>(not counting streaming assets)</size>"
: ""));
GUILayout.Label(largestAssetCategoryLabel, BuildReportTool.Window.Settings.INFO_TEXT_STYLE_NAME);
GUILayout.Space(20);
GUILayout.EndVertical();
// 2nd column
GUILayout.BeginVertical(GUILayout.MaxWidth(250));
GUILayout.Label("Made for:", BuildReportTool.Window.Settings.INFO_TITLE_STYLE_NAME);
GUILayout.Label(buildReportToDisplay.BuildType, BuildReportTool.Window.Settings.INFO_SUBTITLE_STYLE_NAME);
GUILayout.Label("Built in:", BuildReportTool.Window.Settings.INFO_TITLE_STYLE_NAME);
GUILayout.Label(buildReportToDisplay.UnityVersionDisplayed, BuildReportTool.Window.Settings.INFO_SUBTITLE_STYLE_NAME);
GUILayout.EndVertical();
DrawScenesInBuild(buildReportToDisplay.ScenesInBuild);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
var numberOfTopUsed = buildReportToDisplay.HasUsedAssets ? buildReportToDisplay.UsedAssets.NumberOfTopLargest : 0;
var numberOfTopUnused = buildReportToDisplay.HasUnusedAssets ? buildReportToDisplay.UnusedAssets.NumberOfTopLargest : 0;
if (Event.current.type == EventType.Layout)
{
_showTopUsed = numberOfTopUsed > 0 && buildReportToDisplay.UsedAssets.TopLargest != null;
_showTopUnused = numberOfTopUnused > 0 && buildReportToDisplay.UnusedAssets.TopLargest != null;
}
// 1st column
GUILayout.BeginVertical();
if (_showTopUsed)
{
GUILayout.Label(string.Format("Top {0} largest in build:", numberOfTopUsed.ToString()), BuildReportTool.Window.Settings.INFO_TITLE_STYLE_NAME);
if (!BuildReportTool.Options.AutoResortAssetsWhenUnityEditorRegainsFocus && GUILayout.Button("Refresh", GUILayout.Height(20), GUILayout.MaxWidth(520)))
{
buildReportToDisplay.RecategorizeUsedAssets();
buildReportToDisplay.FlagOkToRefresh();
}
DrawAssetList(buildReportToDisplay.UsedAssets, true, buildReportToDisplay, assetDependencies);
}
GUILayout.EndVertical();
GUILayout.Space(50);
// 2nd column
GUILayout.BeginVertical();
if (_showTopUnused)
{
GUILayout.Label(string.Format("Top {0} largest not in build:", numberOfTopUnused.ToString()), BuildReportTool.Window.Settings.INFO_TITLE_STYLE_NAME);
if (!BuildReportTool.Options.AutoResortAssetsWhenUnityEditorRegainsFocus && GUILayout.Button("Refresh", GUILayout.Height(20), GUILayout.MaxWidth(520)))
{
buildReportToDisplay.RecategorizeUnusedAssets();
buildReportToDisplay.FlagOkToRefresh();
}
DrawAssetList(buildReportToDisplay.UnusedAssets, false, buildReportToDisplay, assetDependencies);
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.EndVertical();
GUILayout.Space(20);
GUILayout.EndVertical();
GUILayout.Space(20); // extra right padding
GUILayout.EndHorizontal();
GUILayout.EndScrollView();
// ------------------------------------------------------
// Continually request repaint, since we need to check the rects
// generated by the GUILayout (using GUILayoutUtility.GetLastRect())
// to make the hover checks work. That's because GetLastRect() only
// works during repaint event.
//
// Later checks below can set requestRepaint to false if there's no
// need to repaint, to help lessen cpu usage.
requestRepaint = true;
if (Event.current.mousePosition.y >= position.height ||
Event.current.mousePosition.y <= 0 ||
Event.current.mousePosition.x <= 0 ||
Event.current.mousePosition.x >= position.width)
{
// mouse is outside the window, no need to repaint, can't show tooltip anyway
// set requestRepaint to false to help lessen cpu usage
requestRepaint = false;
}
var showThumbnailNow = BuildReportTool.Options.ShowTooltipThumbnail &&
_shouldShowThumbnailOnHoveredAsset &&
(_assetUsedEntryHoveredIdx != -1 || _assetUnusedEntryHoveredIdx != -1);
var zoomInChanged = false;
if (showThumbnailNow)
{
var prevZoomedIn = BRT_BuildReportWindow.ZoomedInThumbnails;
// if thumbnail is currently showing, we process the inputs
// (ctrl zooms in on thumbnail, alt toggles alpha blend)
BRT_BuildReportWindow.ProcessThumbnailControls();
if (prevZoomedIn != BRT_BuildReportWindow.ZoomedInThumbnails)
{
zoomInChanged = true;
}
}
else
{
// no thumbnail currently shown. ensure the controls that
// need to be reset to initial state are reset
BRT_BuildReportWindow.ResetThumbnailControls();
}
if (!zoomInChanged && !Event.current.alt &&
!BRT_BuildReportWindow.MouseMovedNow && !BRT_BuildReportWindow.LastMouseMoved)
{
// mouse hasn't moved, and no request to zoom-in thumbnail or toggle thumbnail alpha
// no need to repaint because nothing has changed
// set requestRepaint to false to help lessen cpu usage
requestRepaint = false;
}
var shouldShowAssetEndUsersTooltipNow = BuildReportTool.Options.ShowAssetPrimaryUsersInTooltipIfAvailable &&
BRT_BuildReportWindow.ShouldHoveredAssetShowEndUserTooltip(assetDependencies) &&
(_assetUsedEntryHoveredIdx != -1 || _assetUnusedEntryHoveredIdx != -1);
if (Event.current.type == EventType.Repaint)
{
if (showThumbnailNow && shouldShowAssetEndUsersTooltipNow)
{
// draw thumbnail and end users below it
BRT_BuildReportWindow.DrawThumbnailEndUsersTooltip(position, assetDependencies);
}
else if (shouldShowAssetEndUsersTooltipNow)
{
// draw only end users in tooltip
BRT_BuildReportWindow.DrawEndUsersTooltip(position, assetDependencies);
}
else if (showThumbnailNow)
{
// draw only thumbnail in tooltip
BRT_BuildReportWindow.DrawThumbnailTooltip(position);
}
}
}
public override void RefreshData(BuildInfo buildReport)
{
}
private IEnumerable <BuildInfo> GetBuildInfos()
{
return(DependencyBuildInfo.Select(buildInfoItem => BuildInfo.Get(
buildInfoItem.ItemSpec,
buildInfoItem.GetMetadata("RawUrl"))));
}
public virtual void Update(double timeNow, double deltaTime, BuildInfo buildReportToDisplay, AssetDependencies assetDependencies)
{
}
void DrawBuildSettings(BuildInfo buildReportToDisplay, UnityBuildSettings settings)
{
DrawSettingsGroupTitle("Build Settings");
// --------------------------------------------------
// build settings
if (IsShowingStandaloneSettings)
{
DrawSetting("Enable headless mode:", settings.EnableHeadlessMode);
}
else if (IsShowingWindowsStoreAppSettings)
{
DrawSetting("Generate reference projects:", settings.WSAGenerateReferenceProjects);
DrawSetting("Target Windows Store App SDK:", settings.WSASDK);
}
else if (IsShowingWebPlayerSettings)
{
DrawSetting("Web player streaming:", settings.WebPlayerEnableStreaming);
DrawSetting("Web player offline deployment:", settings.WebPlayerDeployOffline);
DrawSetting("First streamed level with \"Resources\" assets:", settings.WebPlayerFirstStreamedLevelWithResources);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingWebGlSettings)
{
DrawSetting("WebGL optimization level:", UnityBuildSettingsUtility.GetReadableWebGLOptimizationLevel(settings.WebGLOptimizationLevel));
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingiOSSettings)
{
DrawSetting("SDK version:", settings.iOSSDKVersionUsed);
DrawSetting("Target iOS version:", settings.iOSTargetOSVersion);
DrawSetting("Target device:", settings.iOSTargetDevice);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingAndroidSettings)
{
DrawSetting("Build subtarget:", settings.AndroidBuildSubtarget);
DrawSetting("Min SDK version:", settings.AndroidMinSDKVersion);
DrawSetting("Target device:", settings.AndroidTargetDevice);
DrawSetting("Automatically create APK Expansion File:", settings.AndroidUseAPKExpansionFiles);
DrawSetting("Export Android project:", settings.AndroidAsAndroidProject);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
DrawSetting("Is game:", settings.AndroidIsGame);
DrawSetting("TV-compatible:", settings.AndroidTvCompatible);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
DrawSetting("Force Internet permission:", settings.AndroidForceInternetPermission);
DrawSetting("Force SD card permission:", settings.AndroidForceSDCardPermission);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
DrawSetting("Key alias name:", settings.AndroidKeyAliasName);
DrawSetting("Keystore name:", settings.AndroidKeystoreName);
}
else if (IsShowingBlackberrySettings)
{
DrawSetting("Build subtarget:", settings.BlackBerryBuildSubtarget);
DrawSetting("Build type:", settings.BlackBerryBuildType);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
if (UnityMajorVersionUsedIsAtMost(4, buildReportToDisplay.UnityVersion))
{
DrawSetting("Author ID:", settings.BlackBerryAuthorID);
}
DrawSetting("Device address:", settings.BlackBerryDeviceAddress);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
DrawSetting("Save log path:", settings.BlackBerrySaveLogPath);
DrawSetting("Token path:", settings.BlackBerryTokenPath);
DrawSetting("Token author:", settings.BlackBerryTokenAuthor);
DrawSetting("Token expiration:", settings.BlackBerryTokenExpiration);
}
else if (IsShowingXbox360Settings)
{
DrawSetting("Build subtarget:", settings.Xbox360BuildSubtarget);
DrawSetting("Run method:", settings.Xbox360RunMethod);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
DrawSetting("Image .xex filepath:", settings.Xbox360ImageXexFilePath, true);
DrawSetting(".spa filepath:", settings.Xbox360SpaFilePath, true);
DrawSetting("Auto-generate .spa:", settings.Xbox360AutoGenerateSpa);
DrawSetting("Additional title memory size:", settings.Xbox360AdditionalTitleMemSize);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingXboxOneSettings)
{
DrawSetting("Deploy method:", settings.XboxOneDeployMethod);
DrawSetting("Is content package:", settings.XboxOneIsContentPackage);
DrawSetting("Packaging encryption level:", settings.XboxOnePackagingEncryptionLevel);
DrawSetting("Allowed product IDs:", settings.XboxOneAllowedProductIds);
DrawSetting("Disable Kinect GPU reservation:", settings.XboxOneDisableKinectGpuReservation);
DrawSetting("Enable variable GPU:", settings.XboxOneEnableVariableGPU);
DrawSetting("Streaming install launch range:", settings.XboxOneStreamingInstallLaunchRange);
DrawSetting("Persistent local storage size:", settings.XboxOnePersistentLocalStorageSize);
DrawSetting("Socket names:", settings.XboxOneSocketNames);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
DrawSetting("Game OS override path:", settings.XboxOneGameOsOverridePath);
DrawSetting("App manifest override path:", settings.XboxOneAppManifestOverridePath);
DrawSetting("Packaging override path:", settings.XboxOnePackagingOverridePath);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingPS3Settings)
{
DrawSetting("Build subtarget:", settings.SCEBuildSubtarget);
DrawSetting("NP Communications ID:", settings.PS3NpCommsId);
DrawSetting("NP Communications Signature:", settings.PS3NpCommsSig);
DrawSetting("NP Age Rating:", settings.PS3NpAgeRating);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
DrawSetting("Title config filepath:", settings.PS3TitleConfigFilePath, true);
DrawSetting("DLC config filepath:", settings.PS3DLCConfigFilePath, true);
DrawSetting("Thumbnail filepath:", settings.PS3ThumbnailFilePath, true);
DrawSetting("Background image filepath:", settings.PS3BackgroundImageFilePath, true);
DrawSetting("Background sound filepath:", settings.PS3BackgroundSoundFilePath, true);
DrawSetting("Trophy package path:", settings.PS3TrophyPackagePath, true);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
DrawSetting("Compress build with PS Arc:", settings.CompressBuildWithPsArc);
DrawSetting("Need submission materials:", settings.NeedSubmissionMaterials);
DrawSetting("In trial mode:", settings.PS3InTrialMode);
DrawSetting("Disable Dolby encoding:", settings.PS3DisableDolbyEncoding);
DrawSetting("Enable Move support:", settings.PS3EnableMoveSupport);
DrawSetting("Use SPU for Umbra:", settings.PS3UseSPUForUmbra);
DrawSetting("Video memory for vertex buffers:", settings.PS3VideoMemoryForVertexBuffers);
DrawSetting("Video memory for audio:", settings.PS3VideoMemoryForAudio);
DrawSetting("Boot check max save game size (KB):", settings.PS3BootCheckMaxSaveGameSizeKB);
DrawSetting("Save game slots:", settings.PS3SaveGameSlots);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingPS4Settings)
{
DrawSetting("Build subtarget:", settings.PS4BuildSubtarget);
DrawSetting("App parameter 1:", settings.PS4AppParameter1);
DrawSetting("App parameter 2:", settings.PS4AppParameter2);
DrawSetting("App parameter 3:", settings.PS4AppParameter3);
DrawSetting("App parameter 4:", settings.PS4AppParameter4);
DrawSetting("Enter button assignment:", settings.PS4EnterButtonAssignment);
DrawSetting("Remote play key assignment:", settings.PS4RemotePlayKeyAssignment);
DrawSetting("NP Age rating:", settings.PS4NpAgeRating);
DrawSetting("Parental level:", settings.PS4ParentalLevel);
DrawSetting("Enable friend push notifications:", settings.PS4EnableFriendPushNotifications);
DrawSetting("Enable presence push notifications:", settings.PS4EnablePresencePushNotifications);
DrawSetting("Enable session push notifications:", settings.PS4EnableSessionPushNotifications);
DrawSetting("Enable game custom data push notifications:", settings.PS4EnableGameCustomDataPushNotifications);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
DrawSetting("Background image path:", settings.PS4BgImagePath);
DrawSetting("Background music path:", settings.PS4BgMusicPath);
DrawSetting("Startup image path:", settings.PS4StartupImagePath);
DrawSetting("Save data image path:", settings.PS4SaveDataImagePath);
DrawSetting("Params sfx path:", settings.PS4ParamSfxPath);
DrawSetting("NP Title dat path:", settings.PS4NpTitleDatPath);
DrawSetting("NP Trophy Package path:", settings.PS4NpTrophyPackagePath);
DrawSetting("Pronunciations SIG path:", settings.PS4PronunciationSigPath);
DrawSetting("Pronunciations XML path:", settings.PS4PronunciationXmlPath);
DrawSetting("Share file path:", settings.PS4ShareFilePath);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingPSVitaSettings)
{
DrawSetting("Build subtarget:", settings.PSVBuildSubtarget);
DrawSetting("DRM type:", settings.PSVDrmType);
DrawSetting("Upgradable:", settings.PSVUpgradable);
DrawSetting("TV boot mode:", settings.PSVTvBootMode);
DrawSetting("Parental Level:", settings.PSVParentalLevel);
DrawSetting("Health warning:", settings.PSVHealthWarning);
DrawSetting("Enter button assignment:", settings.PSVEnterButtonAssignment);
DrawSetting("Acquire BGM:", settings.PSVAcquireBgm);
DrawSetting("Allow Twitter Dialog:", settings.PSVAllowTwitterDialog);
DrawSetting("NP Communications ID:", settings.PSVNpCommsId);
DrawSetting("NP Communications Signature:", settings.PSVNpCommsSig);
DrawSetting("Age Rating:", settings.PSVNpAgeRating);
DrawSetting("Power mode:", settings.PSVPowerMode);
DrawSetting("Media capacity:", settings.PSVMediaCapacity);
DrawSetting("Storage type:", settings.PSVStorageType);
DrawSetting("TV disable emu:", settings.PSVTvDisableEmu);
DrawSetting("Support Game Boot Message or Game Joining Presence:", settings.PSVNpSupportGbmOrGjp);
DrawSetting("Use lib location:", settings.PSVUseLibLocation);
DrawSetting("Info bar color:", settings.PSVInfoBarColor);
DrawSetting("Show info bar on startup:", settings.PSVShowInfoBarOnStartup);
DrawSetting("Save data quota:", settings.PSVSaveDataQuota);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
DrawSetting("Manual filepath:", settings.PSVManualPath);
DrawSetting("Trophy package filepath:", settings.PSVTrophyPackagePath);
DrawSetting("Params Sfx filepath:", settings.PSVParamSfxPath);
DrawSetting("Patch change info filepath:", settings.PSVPatchChangeInfoPath);
DrawSetting("Patch original filepath:", settings.PSVPatchOriginalPackPath);
DrawSetting("Keystone filepath:", settings.PSVKeystoneFilePath);
DrawSetting("Live Area BG image filepath:", settings.PSVLiveAreaBgImagePath);
DrawSetting("Live Area Gate image filepath:", settings.PSVLiveAreaGateImagePath);
DrawSetting("Custom Live Area path:", settings.PSVCustomLiveAreaPath);
DrawSetting("Live Area trial path:", settings.PSVLiveAreaTrialPath);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingSamsungTvSettings)
{
DrawSetting("Device address:", settings.SamsungTVDeviceAddress);
DrawSetting("Author:", settings.SamsungTVAuthor);
DrawSetting("Author email:", settings.SamsungTVAuthorEmail);
DrawSetting("Website:", settings.SamsungTVAuthorWebsiteUrl);
DrawSetting("Category:", settings.SamsungTVCategory);
DrawSetting("Description:", settings.SamsungTVDescription);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
if (IsShowingiOSSettings && UnityMajorVersionUsedIsAtMost(4, buildReportToDisplay.UnityVersion))
{
DrawSetting("Is appended build:", settings.iOSAppendedToProject);
}
DrawSetting("Install in build folder:", settings.InstallInBuildFolder);
if (UnityMajorVersionUsedIsAtMost(4, buildReportToDisplay.UnityVersion))
{
DrawSetting("Physics code stripped:", settings.StripPhysicsCode);
}
DrawSetting("Prebake collision meshes:", settings.BakeCollisionMeshes);
DrawSetting("Optimize mesh data:", settings.StripUnusedMeshComponents);
if (IsShowingMobileSettings)
{
DrawSetting("Stripping level:", settings.StrippingLevelUsed);
}
else if (IsShowingWebGlSettings)
{
DrawSetting("Strip engine code (IL2CPP):", settings.StripEngineCode);
}
}
public override IBuildContext GetContext(Expression expression, int level, BuildInfo buildInfo)
{
if (Collection != null)
{
if (expression == null)
{
return(Collection.GetContext(expression, level, buildInfo));
}
var root = expression.GetRootObject();
if (root != Lambda.Parameters[0])
{
return(Collection.GetContext(expression, level, buildInfo));
}
}
return(base.GetContext(expression, level, buildInfo));
}
/// <summary>
/// 设定打包信息
/// </summary>
private static void SetBuildInfoFromParameters()
{
// 平台类型
TPlatformType platformType = BuildParameters.PlatformType;
if (TPlatformType.None != platformType)
{
BuildInfo.GetInstance().PlatformType = platformType;
}
// 工程名
string projectName = BuildParameters.ProjectName;
if (false == string.IsNullOrEmpty(projectName))
{
BuildInfo.GetInstance().BuildName = projectName;
}
// 打包ID
string buildID = BuildParameters.BuildId;
if (false == string.IsNullOrEmpty(buildID))
{
BuildInfo.GetInstance().BuildID = buildID;
}
// 打包模式
TBuildMode buildMode = BuildParameters.BuildMode;
if (TBuildMode.None != buildMode)
{
BuildInfo.GetInstance().BuildMode = buildMode;
}
// 版本号
string buildVersion = BuildParameters.BuildVersion;
if (false == string.IsNullOrEmpty(buildVersion))
{
BuildInfo.GetInstance().BuildVersion = buildVersion;
}
// VersionCode
int buildVersionCode = BuildParameters.BuildVersionCode;
if (-1 != buildVersionCode)
{
BuildInfo.GetInstance().BuildVersionCode = buildVersionCode;
}
// 中心服务器版本号
string centerVersion = BuildParameters.CenterVersion;
if (false == string.IsNullOrEmpty(centerVersion))
{
BuildInfo.GetInstance().CenterVersion = centerVersion;
}
// 打包号
int buildNumber = BuildParameters.BuildNumber;
if (-1 < buildNumber)
{
BuildInfo.GetInstance().BuildNumber = buildNumber;
}
// 是否跳过下载
bool isSkipDownload = BuildParameters.IsSkipDownload;
ServersConf.GetInstance().SkipDownload = isSkipDownload;
}
public abstract void RefreshData(BuildInfo buildReport);
private static DependencyBuildInfo GetBuildInfoDependency(string target, string fragment)
{
BuildInfo buildInfo = BuildInfo.Get(target, $"{config.VersionsUrl}/{fragment}", false);
return(new DependencyBuildInfo(buildInfo, true, Enumerable.Empty <string>()));
}
static void ExportXcodeProject()
{
const string funcBlock = "ProjectBuild.ExportXcodeProject()";
BuildLogger.OpenBlock(funcBlock);
// 设定打包信息
SetBuildInfoFromParameters();
// 平台类型
BuildInfo.GetInstance().PlatformType = TPlatformType.iOS;
TBuildMode buildMode = BuildInfo.GetInstance().BuildMode;
BuildLogger.LogMessage("BuildMode:{0}", buildMode.ToString());
// 初始化
InitForExportXcodeProject();
BuildLogger.LogMessage(" --> InitForExportXcodeProject()");
// 预定义宏
//PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS, "GAMELINK");
// 游戏输出目录（iOS）:{OutputDir}/iOS/{ProjectName}
string outputDir = GetOutputDir(BuildTarget.iOS, null);
if (outputDir == null)
{
BuildLogger.LogException("Create Dir Failed.!!(Dir:{0})",
BuildParameters.OutputDir);
throw new ApplicationException();
}
// 打包选项
BuildOptions buildOptionTmp = BuildOptions.None;
if (TBuildMode.Debug == buildMode)
{
buildOptionTmp |= BuildOptions.Development;
buildOptionTmp |= BuildOptions.AllowDebugging;
buildOptionTmp |= BuildOptions.ConnectWithProfiler;
}
else
{
bool isCheatMode = BuildParameters.IsCheatMode;
if (true == isCheatMode)
{
buildOptionTmp |= BuildOptions.Development;
}
}
BuildLogger.LogMessage("BuildOption:{0}", ((int)buildOptionTmp).ToString());
// 工程名
string projectName = BuildInfo.GetInstance().BuildName;
BuildLogger.LogMessage("ProjectName:{0}", projectName);
// 游戏名字
string gameName = BuildParameters.GameName;
if (true == string.IsNullOrEmpty(gameName))
{
gameName = projectName;
}
PlayerSettings.iOS.applicationDisplayName = gameName;
BuildLogger.LogMessage("GameName:{0}", gameName);
// BuildID
string buildID = BuildInfo.GetInstance().BuildID;
if (false == string.IsNullOrEmpty(buildID))
{
#if UNITY_5_5_OR_NEWER
PlayerSettings.applicationIdentifier = buildID;
#else
PlayerSettings.bundleIdentifier = buildID;
#endif
}
BuildLogger.LogMessage("BuildID:{0}", buildID);
// 版本号
string buildVersion = BuildInfo.GetInstance().BuildVersion;
PlayerSettings.bundleVersion = buildVersion;
BuildLogger.LogMessage("BuildVersion:{0}", buildVersion);
// 中心服务器版本号
string centerVersion = BuildInfo.GetInstance().CenterVersion;
BuildLogger.LogMessage("CenterVersion:{0}", centerVersion);
// XCode工程目录
string XcodeProject = string.Format("{0}/XcodeProject", outputDir);
// 输出打包信息
OutputBuildInfo(buildVersion, projectName);
// 开发者模式
if (BuildOptions.Development == buildOptionTmp)
{
// 打包之前，将非资源对象，临时移动到临时文件夹
AssetBundles.Common.MoveUnResources();
}
// 打包成XCode工程目录
#if UNITY_5_OR_NEWER
string error = BuildPipeline.BuildPlayer(
GetBuildScenes(),
XcodeProject,
BuildTarget.iOS, buildOptionTmp);
#else
string error = BuildPipeline.BuildPlayer(
GetBuildScenes(),
XcodeProject,
BuildTarget.iOS, buildOptionTmp);
#endif
// 开发者模式
if (BuildOptions.Development == buildOptionTmp)
{
// 恢复非资源性文件
AssetBundles.Common.MoveBackUnResources();
}
// 存在错误则，打包编译失败
if (error != null && !error.Equals("") && !(error.Length == 0))
{
BuildLogger.LogException("iOS Build Failed!!!(error:{0})", error);
BuildLogger.CloseBlock();
throw new ApplicationException();
}
else
{
BuildLogger.LogMessage("iOS Build Successed.");
}
BuildLogger.CloseBlock();
}
/// <summary>
/// 检测服务器上得各个路径.
/// </summary>
/// <returns><c>true</c>, OK, <c>false</c> NG.</returns>
private IEnumerator CheckDirsOnServer()
{
string buildName = BuildInfo.GetInstance().BuildName;
// 上传服务器信息
UploadServerInfo server = ServersConf.GetInstance().UploadServer;
if (server == null)
{
this._State = TRunState.GetServerInfoFailed;
yield return(null);
}
// 取得上传URL
string uploadBaseUrl = ServersConf.GetUploadBaseURL(server);
int startIndex = uploadBaseUrl.IndexOf(buildName);
string dirsInfo = uploadBaseUrl.Substring(startIndex);
string[] dirNames = dirsInfo.Split('/');
string curUrl = uploadBaseUrl.Substring(0, startIndex - 1);
string createdDir = null;
for (int i = 0; i < dirNames.Length; ++i)
{
if (this.CheckDirOnServer(server, curUrl, dirNames [i], ref createdDir) == true)
{
curUrl = string.Format("{0}/{1}", curUrl, dirNames [i]);
yield return(new WaitForEndOfFrame());
}
else
{
this._State = TRunState.CheckDirFailed;
yield return(null);
}
}
// 检测目录
// Url:<ParentUrl>/bundles
if (this.CheckDirOnServer(server, curUrl, "bundles", ref createdDir) == true)
{
curUrl = string.Format("{0}/{1}", curUrl, "bundles");
yield return(new WaitForEndOfFrame());
}
else
{
this._State = TRunState.CheckDirFailed;
yield return(null);
}
// Url:<ParentUrl>/<BuildTarget>
string buildTarget = UploadList.GetInstance().BuildTarget;
if (this.CheckDirOnServer(server, curUrl, buildTarget, ref createdDir) == true)
{
curUrl = string.Format("{0}/{1}", curUrl, buildTarget);
yield return(new WaitForEndOfFrame());
}
else
{
this._State = TRunState.CheckDirFailed;
yield return(null);
}
// Url:<ParentUrl>/<AppVersion>
string appVersion = UploadList.GetInstance().AppVersion;
if (this.CheckDirOnServer(server, curUrl, appVersion, ref createdDir) == true)
{
curUrl = string.Format("{0}/{1}", curUrl, appVersion);
yield return(new WaitForEndOfFrame());
}
else
{
this._State = TRunState.CheckDirFailed;
yield return(null);
}
// Url:<ParentUrl>/Normal
string subUrlTmp = curUrl;
string subCreatedDirTmp = createdDir;
if (this.CheckDirOnServer(server, subUrlTmp,
UploadList.AssetBundleDirNameOfNormal, ref subCreatedDirTmp) == true)
{
subUrlTmp = string.Format("{0}/{1}", subUrlTmp, UploadList.AssetBundleDirNameOfNormal);
yield return(new WaitForEndOfFrame());
}
else
{
this._State = TRunState.CheckDirFailed;
yield return(null);
}
// Url:<ParentUrl>/Scene
subUrlTmp = curUrl;
subCreatedDirTmp = createdDir;
if (this.CheckDirOnServer(server, subUrlTmp,
UploadList.AssetBundleDirNameOfScenes, ref subCreatedDirTmp) == true)
{
subUrlTmp = string.Format("{0}/{1}", subUrlTmp, UploadList.AssetBundleDirNameOfScenes);
yield return(new WaitForEndOfFrame());
}
else
{
this._State = TRunState.CheckDirFailed;
yield return(null);
}
yield return(null);
}
protected override SequenceConvertInfo Convert(
ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo, ParameterExpression param)
{
return(null);
}
// ================================================================================================
public override void DrawGUI(Rect position, BuildInfo buildReportToDisplay, AssetDependencies assetDependencies,
TextureData textureData, UnityBuildReport unityBuildReport, out bool requestRepaint)
{
requestRepaint = false;
if (unityBuildReport == null)
{
return;
}
if (_logIcon == null)
{
var logIcons = GUI.skin.FindStyle("LogMessageIcons");
if (logIcons != null)
{
_logIcon = logIcons.normal.background;
_warnIcon = logIcons.hover.background;
_errorIcon = logIcons.active.background;
_logFilterLabel.image = _logIcon;
_warnFilterLabel.image = _warnIcon;
_errorFilterLabel.image = _errorIcon;
}
}
if (_indentLine == null)
{
_indentLine = GUI.skin.GetStyle("IndentStyle1").normal.background;
}
Texture2D prevArrow = GUI.skin.GetStyle(BuildReportTool.Window.Settings.BIG_LEFT_ARROW_ICON_STYLE_NAME).normal.background;
Texture2D nextArrow = GUI.skin.GetStyle(BuildReportTool.Window.Settings.BIG_RIGHT_ARROW_ICON_STYLE_NAME).normal.background;
var steps = unityBuildReport.BuildProcessSteps;
if (steps == null)
{
return;
}
// --------------------------------
#region Steps
float height = position.height * _buildStepsHeightPercent;
var maxHeight = (steps.Length + 1) * 20;
if (height > maxHeight)
{
height = maxHeight;
}
GUILayout.BeginHorizontal(GUILayout.Height(height));
#region Column 1 (Step Name)
GUILayout.BeginVertical(BRT_BuildReportWindow.LayoutNone);
GUILayout.Label("Step", BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_STYLE_NAME);
_scrollPos = GUILayout.BeginScrollView(_scrollPos,
BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME,
BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME, BRT_BuildReportWindow.LayoutNone);
bool useAlt = true;
for (int i = 0; i < steps.Length; ++i)
{
string styleToUse = useAlt
? BuildReportTool.Window.Settings.LIST_SMALL_ALT_STYLE_NAME
: BuildReportTool.Window.Settings.LIST_SMALL_STYLE_NAME;
if (i == _selectedStepIdx)
{
styleToUse = BuildReportTool.Window.Settings.LIST_SMALL_SELECTED_NAME;
}
GUILayout.BeginHorizontal(styleToUse);
GUILayout.Space(steps[i].Depth * 20);
if (GUILayout.Button(steps[i].Name, styleToUse, BRT_BuildReportWindow.LayoutListHeight))
{
SelectStep(i, steps);
}
GUILayout.EndHorizontal();
if (Event.current.type == EventType.Repaint)
{
Rect labelRect = GUILayoutUtility.GetLastRect();
var prevColor = GUI.color;
GUI.color = new Color(0, 0, 0, 0.5f);
for (int indentN = 0, indentLen = steps[i].Depth;
indentN < indentLen;
++indentN)
{
var indentRect = new Rect((indentN * 20), labelRect.y, 20, labelRect.height);
GUI.DrawTexture(indentRect, _indentLine, ScaleMode.ScaleAndCrop);
}
GUI.color = prevColor;
}
useAlt = !useAlt;
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
#endregion
#region Column 2 (Warning Count)
GUILayout.BeginVertical(BRT_BuildReportWindow.LayoutNone);
GUILayout.Label("Warning Count", BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_STYLE_NAME);
_scrollPos = GUILayout.BeginScrollView(_scrollPos,
BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME,
BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME, BRT_BuildReportWindow.LayoutNone);
useAlt = true;
for (int i = 0; i < steps.Length; ++i)
{
string styleToUse = useAlt
? BuildReportTool.Window.Settings.LIST_SMALL_ALT_STYLE_NAME
: BuildReportTool.Window.Settings.LIST_SMALL_STYLE_NAME;
if (i == _selectedStepIdx)
{
styleToUse = BuildReportTool.Window.Settings.LIST_SMALL_SELECTED_NAME;
}
if (steps[i].WarnLogCount > 0)
{
if (GUILayout.Button(steps[i].WarnLogCount.ToString(), styleToUse, BRT_BuildReportWindow.LayoutListHeight))
{
SelectStep(i, steps);
}
}
else
{
GUILayout.Label(GUIContent.none, styleToUse, BRT_BuildReportWindow.LayoutListHeight);
}
useAlt = !useAlt;
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
#endregion
#region Column 3 (Error Count)
GUILayout.BeginVertical(BRT_BuildReportWindow.LayoutNone);
GUILayout.Label("Error Count", BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_STYLE_NAME);
_scrollPos = GUILayout.BeginScrollView(_scrollPos,
BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME,
BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME, BRT_BuildReportWindow.LayoutNone);
useAlt = true;
for (int i = 0; i < steps.Length; ++i)
{
string styleToUse = useAlt
? BuildReportTool.Window.Settings.LIST_SMALL_ALT_STYLE_NAME
: BuildReportTool.Window.Settings.LIST_SMALL_STYLE_NAME;
if (i == _selectedStepIdx)
{
styleToUse = BuildReportTool.Window.Settings.LIST_SMALL_SELECTED_NAME;
}
if (steps[i].ErrorLogCount > 0)
{
if (GUILayout.Button(steps[i].ErrorLogCount.ToString(), styleToUse, BRT_BuildReportWindow.LayoutListHeight))
{
SelectStep(i, steps);
}
}
else
{
GUILayout.Label(GUIContent.none, styleToUse, BRT_BuildReportWindow.LayoutListHeight);
}
useAlt = !useAlt;
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
#endregion
#region Last Column (Duration)
GUILayout.BeginVertical(BRT_BuildReportWindow.LayoutNone);
GUILayout.Label("Duration", BuildReportTool.Window.Settings.LIST_COLUMN_HEADER_STYLE_NAME);
_scrollPos = GUILayout.BeginScrollView(_scrollPos,
BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME,
"verticalscrollbar", BRT_BuildReportWindow.LayoutNone);
useAlt = true;
for (int i = 0; i < steps.Length; ++i)
{
string styleToUse = useAlt
? BuildReportTool.Window.Settings.LIST_SMALL_ALT_STYLE_NAME
: BuildReportTool.Window.Settings.LIST_SMALL_STYLE_NAME;
if (i == _selectedStepIdx)
{
styleToUse = BuildReportTool.Window.Settings.LIST_SMALL_SELECTED_NAME;
}
string duration;
if (i == 0)
{
duration = unityBuildReport.TotalBuildTime.ToReadableString();
}
else
{
duration = steps[i].Duration.ToReadableString();
}
GUILayout.Label(duration, styleToUse, BRT_BuildReportWindow.LayoutListHeight);
useAlt = !useAlt;
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
#endregion
GUILayout.EndHorizontal();
if (Event.current.type == EventType.Repaint)
{
_stepsViewRect = GUILayoutUtility.GetLastRect();
}
#endregion
// --------------------------------
#region Logs
GUILayout.BeginHorizontal();
GUILayout.BeginVertical(BRT_BuildReportWindow.LayoutNone);
#region Logs Toolbar
GUILayout.BeginHorizontal(BuildReportTool.Window.Settings.TOP_BAR_BG_STYLE_NAME, BRT_BuildReportWindow.LayoutHeight18);
GUILayout.Space(10);
string logMessagesTitle;
bool hasStepSelected = _selectedStepIdx != -1 &&
steps[_selectedStepIdx].BuildLogMessages != null &&
steps[_selectedStepIdx].BuildLogMessages.Length > 0;
if (hasStepSelected)
{
logMessagesTitle = string.Format("Log Messages of: <i>{0}</i>", steps[_selectedStepIdx].Name);
}
else
{
logMessagesTitle = "Log Messages (Total)";
}
GUILayout.Label(logMessagesTitle, BuildReportTool.Window.Settings.TOP_BAR_LABEL_STYLE_NAME, BRT_BuildReportWindow.LayoutNoExpandWidth);
if (Event.current.type == EventType.Repaint)
{
_dividerRect = GUILayoutUtility.GetLastRect();
}
GUILayout.FlexibleSpace();
int messagePaginationLength = BuildReportTool.Options.LogMessagePaginationLength;
if (GUILayout.Button(prevArrow, BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME,
BRT_BuildReportWindow.LayoutNone) &&
(_logMessageToShowStartOffset - messagePaginationLength >= 0))
{
_logMessageToShowStartOffset -= messagePaginationLength;
}
if (Event.current.type == EventType.Repaint)
{
var prevArrowRect = GUILayoutUtility.GetLastRect();
_dividerRect.xMax = prevArrowRect.x;
}
string paginateLabel;
if (_showPageNumbers)
{
int totalPageNumbers = _totalVisibleMessageCount / messagePaginationLength;
if (_totalVisibleMessageCount % messagePaginationLength > 0)
{
++totalPageNumbers;
}
// the max number of digits for the displayed offset counters
string assetCountDigitNumFormat = string.Format("D{0}", totalPageNumbers.ToString().Length.ToString());
paginateLabel = string.Format("Page {0} of {1}",
((_logMessageToShowStartOffset / messagePaginationLength) + 1).ToString(assetCountDigitNumFormat),
totalPageNumbers.ToString());
}
else
{
// number of assets in current page
int pageLength = Mathf.Min(_logMessageToShowStartOffset + messagePaginationLength, _totalVisibleMessageCount);
int offsetNonZeroBased = _logMessageToShowStartOffset + (pageLength > 0 ? 1 : 0);
// the max number of digits for the displayed offset counters
string assetCountDigitNumFormat = string.Format("D{0}", _totalVisibleMessageCount.ToString().Length.ToString());
paginateLabel = string.Format("Page {0} - {1} of {2}",
offsetNonZeroBased.ToString(assetCountDigitNumFormat),
pageLength.ToString(assetCountDigitNumFormat),
_totalVisibleMessageCount.ToString(assetCountDigitNumFormat));
}
if (GUILayout.Button(paginateLabel, BuildReportTool.Window.Settings.TOP_BAR_LABEL_STYLE_NAME,
BRT_BuildReportWindow.LayoutNone))
{
_showPageNumbers = !_showPageNumbers;
}
if (GUILayout.Button(nextArrow, BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME,
BRT_BuildReportWindow.LayoutNone) &&
(_logMessageToShowStartOffset + messagePaginationLength < _totalVisibleMessageCount))
{
_logMessageToShowStartOffset += messagePaginationLength;
}
GUILayout.Space(8);
var newShowLogMessagesCollapsed = GUILayout.Toggle(_showLogMessagesCollapsed, "Collapse",
BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME, BRT_BuildReportWindow.LayoutNoExpandWidth);
if (newShowLogMessagesCollapsed != _showLogMessagesCollapsed)
{
_showLogMessagesCollapsed = newShowLogMessagesCollapsed;
RefreshTotalVisibleMessageCount();
}
GUILayout.Space(8);
bool newShowLogMessages = GUILayout.Toggle(_showLogMessages, _logFilterLabel,
BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME, BRT_BuildReportWindow.LayoutNoExpandWidth);
bool newShowWarnMessages = GUILayout.Toggle(_showWarnMessages, _warnFilterLabel,
BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME, BRT_BuildReportWindow.LayoutNoExpandWidth);
bool newShowErrorMessages = GUILayout.Toggle(_showErrorMessages, _errorFilterLabel,
BuildReportTool.Window.Settings.TOP_BAR_BTN_STYLE_NAME, BRT_BuildReportWindow.LayoutNoExpandWidth);
if (newShowLogMessages != _showLogMessages)
{
_showLogMessages = newShowLogMessages;
RefreshTotalVisibleMessageCount();
}
if (newShowWarnMessages != _showWarnMessages)
{
_showWarnMessages = newShowWarnMessages;
RefreshTotalVisibleMessageCount();
}
if (newShowErrorMessages != _showErrorMessages)
{
_showErrorMessages = newShowErrorMessages;
RefreshTotalVisibleMessageCount();
}
GUILayout.Space(8);
GUILayout.EndHorizontal();
EditorGUIUtility.AddCursorRect(_dividerRect, MouseCursor.ResizeVertical);
#endregion
if (Event.current.type == EventType.MouseDown &&
Event.current.button == 0 &&
_dividerRect.Contains(Event.current.mousePosition))
{
_draggingDivider = true;
_mouseYOnDividerDragStart = Event.current.mousePosition.y;
_heightOnDividerDragStart = height;
requestRepaint = true;
}
if (Event.current.type == EventType.MouseUp)
{
_draggingDivider = false;
requestRepaint = true;
}
if (_draggingDivider)
{
var newHeight = _heightOnDividerDragStart + (Event.current.mousePosition.y - _mouseYOnDividerDragStart);
_buildStepsHeightPercent = newHeight / position.height;
requestRepaint = true;
}
_logMessagesScrollPos = GUILayout.BeginScrollView(_logMessagesScrollPos,
BuildReportTool.Window.Settings.HIDDEN_SCROLLBAR_STYLE_NAME,
"verticalscrollbar", BRT_BuildReportWindow.LayoutNone);
if (_showLogMessages || _showWarnMessages || _showErrorMessages)
{
if (hasStepSelected)
{
BuildLogMessage[] messages;
if (_showLogMessagesCollapsed)
{
messages = steps[_selectedStepIdx].CollapsedBuildLogMessages;
}
else
{
messages = steps[_selectedStepIdx].BuildLogMessages;
}
int totalToShow = 0;
if (_showLogMessages)
{
totalToShow += steps[_selectedStepIdx].InfoLogCount;
}
if (_showWarnMessages)
{
totalToShow += steps[_selectedStepIdx].WarnLogCount;
}
if (_showErrorMessages)
{
totalToShow += steps[_selectedStepIdx].ErrorLogCount;
}
if (totalToShow > 0)
{
useAlt = true;
int messageToStartIdx = 0;
int messageToStartCount = 0;
for (int m = 0; m < messages.Length; ++m)
{
var logTypeIcon = GetLogIcon(messages[m].LogType);
if (logTypeIcon == _logIcon && !_showLogMessages)
{
continue;
}
if (logTypeIcon == _warnIcon && !_showWarnMessages)
{
continue;
}
if (logTypeIcon == _errorIcon && !_showErrorMessages)
{
continue;
}
++messageToStartCount;
if (messageToStartCount - 1 == _logMessageToShowStartOffset)
{
messageToStartIdx = m;
break;
}
}
DrawMessages(messages, messageToStartIdx, messagePaginationLength,
_selectedStepIdx, 0, ref useAlt, ref requestRepaint);
}
}
else
{
useAlt = true;
int messageToStartIdx = 0;
int stepToStartIdx = 0;
int messageToStartCount = 0;
for (int s = 0; s < steps.Length; ++s)
{
var step = steps[s];
BuildLogMessage[] messages;
if (_showLogMessagesCollapsed)
{
messages = step.CollapsedBuildLogMessages;
}
else
{
messages = step.BuildLogMessages;
}
if (messages == null || messages.Length == 0)
{
continue;
}
int totalToShow = 0;
if (_showLogMessages)
{
totalToShow += step.InfoLogCount;
}
if (_showWarnMessages)
{
totalToShow += step.WarnLogCount;
}
if (_showErrorMessages)
{
totalToShow += step.ErrorLogCount;
}
if (totalToShow == 0)
{
continue;
}
for (int m = 0; m < messages.Length; ++m)
{
var logTypeIcon = GetLogIcon(messages[m].LogType);
if (logTypeIcon == _logIcon && !_showLogMessages)
{
continue;
}
if (logTypeIcon == _warnIcon && !_showWarnMessages)
{
continue;
}
if (logTypeIcon == _errorIcon && !_showErrorMessages)
{
continue;
}
++messageToStartCount;
if (messageToStartCount - 1 == _logMessageToShowStartOffset)
{
messageToStartIdx = m;
stepToStartIdx = s;
break;
}
}
}
int totalShownSoFar = 0;
for (int s = stepToStartIdx; s < steps.Length; ++s)
{
var step = steps[s];
BuildLogMessage[] messages;
if (_showLogMessagesCollapsed)
{
messages = step.CollapsedBuildLogMessages;
}
else
{
messages = step.BuildLogMessages;
}
if (messages == null || messages.Length == 0)
{
continue;
}
int totalToShow = 0;
if (_showLogMessages)
{
if (_showLogMessagesCollapsed)
{
totalToShow += step.CollapsedInfoLogCount;
}
else
{
totalToShow += step.InfoLogCount;
}
}
if (_showWarnMessages)
{
if (_showLogMessagesCollapsed)
{
totalToShow += step.CollapsedWarnLogCount;
}
else
{
totalToShow += step.WarnLogCount;
}
}
if (_showErrorMessages)
{
if (_showLogMessagesCollapsed)
{
totalToShow += step.CollapsedErrorLogCount;
}
else
{
totalToShow += step.ErrorLogCount;
}
}
if (totalToShow == 0)
{
continue;
}
string styleToUse = useAlt
? BuildReportTool.Window.Settings.LIST_SMALL_ALT_STYLE_NAME
: BuildReportTool.Window.Settings.LIST_SMALL_STYLE_NAME;
GUILayout.BeginHorizontal(styleToUse, BRT_BuildReportWindow.LayoutNone);
GUILayout.Space(8);
GUILayout.Button(step.Name, styleToUse, BRT_BuildReportWindow.LayoutHeight25);
GUILayout.EndHorizontal();
useAlt = !useAlt;
DrawMessages(messages, messageToStartIdx, messagePaginationLength - totalShownSoFar,
s, 20, ref useAlt, ref requestRepaint);
totalShownSoFar += totalToShow;
if (totalShownSoFar >= messagePaginationLength)
{
break;
}
}
}
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
GUILayout.EndHorizontal();
#endregion
// if clicked on nothing interactable, then remove selection
if (GUI.Button(_stepsViewRect, GUIContent.none, "HiddenScrollbar"))
{
SelectStep(-1, steps);
}
}
void DrawAssetList(BuildReportTool.AssetList assetList, bool usedAssets, BuildInfo buildReportToDisplay, AssetDependencies assetDependencies)
{
if (assetList == null || assetList.TopLargest == null)
{
//Debug.LogError("no top ten largest");
return;
}
BuildReportTool.SizePart[] assetsToShow = assetList.TopLargest;
if (assetsToShow == null)
{
//Debug.LogError("no top ten largest");
return;
}
bool useAlt = true;
var newEntryHoveredIdx = -1;
BuildReportTool.SizePart newEntryHovered = null;
Rect newEntryHoveredRect = new Rect();
Rect iconRect = new Rect();
var hoveringOverIcon = false;
//var hoveringOverLabel = false;
GUILayout.BeginHorizontal();
// 1st column: name
GUILayout.BeginVertical();
for (int n = 0; n < assetsToShow.Length; ++n)
{
BuildReportTool.SizePart b = assetsToShow[n];
string styleToUse = useAlt ? BuildReportTool.Window.Settings.LIST_NORMAL_ALT_STYLE_NAME : BuildReportTool.Window.Settings.LIST_NORMAL_STYLE_NAME;
string iconStyleToUse = useAlt ? BuildReportTool.Window.Settings.LIST_ICON_ALT_STYLE_NAME : BuildReportTool.Window.Settings.LIST_ICON_STYLE_NAME;
Texture icon = AssetDatabase.GetCachedIcon(b.Name);
GUILayout.BeginHorizontal();
if (icon == null)
{
// no icon, just add space so it aligns with the other entries
GUILayout.Label(string.Empty, iconStyleToUse, GUILayout.Width(28), GUILayout.Height(30));
}
else
{
GUILayout.Button(icon, iconStyleToUse, GUILayout.Width(28), GUILayout.Height(30));
}
if (Event.current.type == EventType.Repaint)
{
iconRect = GUILayoutUtility.GetLastRect();
// if mouse is hovering over asset entry's icon (not the label)
// draw a border on the asset icon
if (iconRect.Contains(Event.current.mousePosition))
{
hoveringOverIcon = true;
newEntryHoveredIdx = n;
newEntryHovered = b;
newEntryHoveredRect = iconRect;
GUI.Box(iconRect, icon, "IconHovered");
}
}
string prettyName = string.Format(" {0}. {1}", (n + 1).ToString(), System.IO.Path.GetFileName(b.Name));
if (GUILayout.Button(prettyName, styleToUse, GUILayout.MinWidth(100), GUILayout.MaxWidth(400), GUILayout.Height(30)))
{
Utility.PingAssetInProject(b.Name);
}
if (newEntryHoveredIdx == -1 && Event.current.type == EventType.Repaint)
{
var labelRect = GUILayoutUtility.GetLastRect();
// if mouse is hovering over asset entry's label
// draw a border on the asset icon
if (labelRect.Contains(Event.current.mousePosition))
{
//hoveringOverLabel = true;
newEntryHoveredIdx = n;
newEntryHovered = b;
newEntryHoveredRect = labelRect;
GUI.Box(iconRect, icon, "IconHovered");
}
}
GUILayout.EndHorizontal();
useAlt = !useAlt;
}
GUILayout.EndVertical();
if (Event.current.type == EventType.Repaint)
{
if (usedAssets)
{
_assetUsedEntryHoveredIdx = newEntryHoveredIdx;
}
else
{
_assetUnusedEntryHoveredIdx = newEntryHoveredIdx;
}
if (newEntryHoveredIdx != -1)
{
string hoveredAssetPath = newEntryHovered != null ? newEntryHovered.Name : null;
// ----------------
// update what is considered the hovered asset, for use later on
// when the tooltip will be drawn
BRT_BuildReportWindow.UpdateHoveredAsset(hoveredAssetPath, newEntryHoveredRect,
usedAssets, buildReportToDisplay, assetDependencies);
// ----------------
// if mouse is hovering over the correct area, we signify that
// the tooltip thumbnail should be drawn
if (BuildReportTool.Options.ShowTooltipThumbnail &&
(BuildReportTool.Options.ShowThumbnailOnHoverLabelToo || hoveringOverIcon) &&
BRT_BuildReportWindow.GetAssetPreview(hoveredAssetPath) != null)
{
_shouldShowThumbnailOnHoveredAsset = true;
}
else
{
_shouldShowThumbnailOnHoveredAsset = false;
}
}
}
// 2nd column: size
var useRawSize = (usedAssets && !BuildReportTool.Options.ShowImportedSizeForUsedAssets) || !usedAssets;
useAlt = true;
GUILayout.BeginVertical();
for (int n = 0; n < assetsToShow.Length; ++n)
{
BuildReportTool.SizePart b = assetsToShow[n];
string styleToUse = useAlt ? BuildReportTool.Window.Settings.LIST_NORMAL_ALT_STYLE_NAME : BuildReportTool.Window.Settings.LIST_NORMAL_STYLE_NAME;
GUILayout.Label(useRawSize ? b.RawSize : b.ImportedSize, styleToUse, GUILayout.MaxWidth(100), GUILayout.Height(30));
useAlt = !useAlt;
}
GUILayout.EndVertical();
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
static void BuildForAndroid()
{
const string funcBlock = "ProjectBuild.BuildForAndroid()";
BuildLogger.OpenBlock(funcBlock);
// 设定打包信息
SetBuildInfoFromParameters();
TBuildMode buildMode = BuildInfo.GetInstance().BuildMode;
BuildLogger.LogMessage("BuildMode:{0}", buildMode.ToString());
// 输出格式（{ProjectName}_v{ProjectVersion}_{buildNumber}_YYYYMMDDHHMMSS.apk）
string buildTime = BuildParameters.BuildTime;
// 输出路径
// 游戏输出目录（Android）:{OutputDir}/Android/{ProjectName}
string outputDir = GetOutputDir(BuildTarget.Android, BuildParameters.OutputDir);
if (outputDir == null)
{
BuildLogger.LogException("Create Dir Failed.!!(Dir:{0})",
BuildParameters.OutputDir);
throw new ApplicationException();
}
// 打包选项
BuildOptions buildOptionTmp = BuildOptions.None;
if (TBuildMode.Debug == buildMode)
{
buildOptionTmp |= BuildOptions.Development;
buildOptionTmp |= BuildOptions.AllowDebugging;
buildOptionTmp |= BuildOptions.ConnectWithProfiler;
}
else
{
bool isCheatMode = BuildParameters.IsCheatMode;
if (true == isCheatMode)
{
buildOptionTmp |= BuildOptions.Development;
}
}
BuildLogger.LogMessage("BuildOption:{0}", ((int)buildOptionTmp).ToString());
// 版本号
string buildVersion = BuildInfo.GetInstance().BuildVersion;
if (string.IsNullOrEmpty(buildVersion) == false)
{
PlayerSettings.bundleVersion = buildVersion;
}
BuildLogger.LogMessage("BuildVersion:{0}", buildVersion);
// buildVersionCode
int buildVersionCode = BuildInfo.GetInstance().BuildVersionCode;
PlayerSettings.Android.bundleVersionCode = buildVersionCode;
BuildLogger.LogMessage("BundleVersionCode:{0}", buildVersionCode.ToString());
// 中心服务器版本号
string centerVersion = BuildInfo.GetInstance().CenterVersion;
BuildLogger.LogMessage("CenterVersion:{0}", centerVersion);
// 工程名
string projectName = BuildInfo.GetInstance().BuildName;
BuildLogger.LogMessage("ProjectName:{0}", projectName);
// 游戏名字
string gameName = BuildParameters.GameName;
if (true == string.IsNullOrEmpty(gameName))
{
gameName = projectName;
}
PlayerSettings.productName = gameName;
BuildLogger.LogMessage("GameName:{0}", gameName);
// BuildID
string buildID = BuildInfo.GetInstance().BuildID;
if (false == string.IsNullOrEmpty(buildID))
{
#if UNITY_5_5_OR_NEWER
PlayerSettings.applicationIdentifier = buildID;
#else
PlayerSettings.bundleIdentifier = buildID;
#endif
}
BuildLogger.LogMessage("BuildID:{0}", buildID);
// 初始化
InitForAndroidBuild();
BuildLogger.LogMessage(" --> InitForAndroidBuild()");
// Apk输出路径
int buildNumber = BuildInfo.GetInstance().BuildNumber;
BuildLogger.LogMessage("BuildNumber:{0}", buildNumber.ToString());
string apkPath = string.Format("{0}/{1}_{2}_v{3}_-_{4}_{5}.apk",
outputDir,
projectName,
buildMode,
buildVersion,
buildTime, buildID);
if (0 < buildNumber)
{
apkPath = string.Format("{0}/{1}_{2}_v{3}_{4}_{5}_{6}.apk",
outputDir,
projectName,
buildMode,
buildVersion,
buildNumber,
buildTime, buildID);
}
BuildLogger.LogMessage("Apk File Path:{0}", apkPath);
// 输出打包信息
OutputBuildInfo(buildVersion, projectName);
// 开发者模式
if (BuildOptions.Development == buildOptionTmp)
{
// 打包之前，移除非资源对象
AssetBundles.Common.MoveUnResources();
}
// Android下IL2CPP不支持，所以设置回Mono
PlayerSettings.SetPropertyInt("ScriptingBackend", (int)ScriptingImplementation.Mono2x, BuildTarget.Android);
string error = BuildPipeline.BuildPlayer(GetBuildScenes(), apkPath, BuildTarget.Android, buildOptionTmp);
// 开发者模式
if (BuildOptions.Development == buildOptionTmp)
{
// 打包之后，恢复非资源对象
AssetBundles.Common.MoveBackUnResources();
}
if (error != null && !error.Equals("") && !(error.Length == 0))
{
BuildLogger.LogException("Android Build Failed!!!(error:{0})", error);
BuildLogger.CloseBlock();
throw new ApplicationException();
}
else
{
BuildLogger.LogMessage("Android Build Successed.");
}
BuildLogger.CloseBlock();
}
static partial void AssignServiceVersionTo(BuildInfo buildInfo);
public abstract void DrawGUI(Rect position, BuildInfo buildReportToDisplay);
public override void DrawGUI(Rect position, BuildInfo buildReportToDisplay)
{
BuildSettingCategory b = ReportGenerator.GetBuildSettingCategoryFromBuildValues(buildReportToDisplay);
_buildTargetOfReport = UnityBuildSettingsUtility.GetReadableBuildSettingCategory(b);
UnityBuildSettings settings = buildReportToDisplay.UnityBuildSettings;
if (settings == null)
{
Utility.DrawCentralMessage(position, "No \"Project Settings\" recorded in this build report.");
return;
}
// ----------------------------------------------------------
// top bar
GUILayout.Space(1);
GUILayout.BeginHorizontal();
GUILayout.Label(" ", BuildReportTool.Window.Settings.TOP_BAR_BG_STYLE_NAME);
GUILayout.Space(8);
GUILayout.Label("Build Target: ", BuildReportTool.Window.Settings.TOP_BAR_LABEL_STYLE_NAME);
InitializeDropdownBoxLabelsIfNeeded();
_selectedSettingsIdxFromDropdownBox = EditorGUILayout.Popup(_selectedSettingsIdxFromDropdownBox, _settingDropdownBoxLabels, BuildReportTool.Window.Settings.FILE_FILTER_POPUP_STYLE_NAME);
GUILayout.Space(15);
GUILayout.Label("Note: Project was built in " + _buildTargetOfReport + " target", BuildReportTool.Window.Settings.TOP_BAR_LABEL_STYLE_NAME);
GUILayout.FlexibleSpace();
_settingsShown = UnityBuildSettingsUtility.GetSettingsCategoryFromIdx(_selectedSettingsIdxFromDropdownBox);
GUILayout.EndHorizontal();
// ----------------------------------------------------------
_scrollPos = GUILayout.BeginScrollView(_scrollPos);
GUILayout.BeginHorizontal();
GUILayout.Space(10);
GUILayout.BeginVertical();
GUILayout.Space(10);
// =================================================================
DrawProjectSettings(buildReportToDisplay, settings);
GUILayout.Space(SETTINGS_GROUP_SPACING);
// =================================================================
DrawPathSettings(buildReportToDisplay, settings);
GUILayout.Space(SETTINGS_GROUP_SPACING);
// =================================================================
DrawBuildSettings(buildReportToDisplay, settings);
GUILayout.Space(SETTINGS_GROUP_SPACING);
// =================================================================
DrawRuntimeSettings(buildReportToDisplay, settings);
// --------------------------------------------------
// security settings
if (IsShowingMacSettings)
{
DrawSetting("Use App Store validation:", settings.MacUseAppStoreValidation);
}
else if (IsShowingAndroidSettings)
{
DrawSetting("Use license verification:", settings.AndroidUseLicenseVerification);
}
GUILayout.Space(SETTINGS_GROUP_SPACING);
// =================================================================
DrawDebugSettings(buildReportToDisplay, settings);
GUILayout.Space(SETTINGS_GROUP_SPACING);
// =================================================================
DrawCodeSettings(buildReportToDisplay, settings);
GUILayout.Space(SETTINGS_GROUP_SPACING);
// =================================================================
DrawGraphicsSettings(buildReportToDisplay, settings);
GUILayout.Space(SETTINGS_GROUP_SPACING);
GUILayout.Space(10);
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.EndScrollView();
}
public bool TryDetectVisualStudio(IReadOnlyDictionary <string, string> buildValues, out BuildInfo buildInfo)
{
buildInfo = null;
if (buildValues == null || !buildValues.Any())
{
return(false);
}
if (!buildValues.TryGetValue("VisualStudio", out var visualStudio))
{
return(false);
}
buildInfo = new BuildInfo
{
ProductName = "Microsoft Visual Studio",
ProductVersion = visualStudio,
};
if (buildValues.TryGetValue("OperatingSystem", out var win10))
{
var firstUnit = win10.Split(' ')[0];
buildInfo.OperatingSystem = WindowsNames.GetOperatingSystemFromNameAndVersion(firstUnit).ToString();
buildInfo.Components = new Dictionary <string, string>(buildValues);
}
return(true);
}
void DrawGraphicsSettings(BuildInfo buildReportToDisplay, UnityBuildSettings settings)
{
DrawSettingsGroupTitle("Graphics Settings");
DrawSetting("Use 32-bit display buffer:", settings.Use32BitDisplayBuffer);
DrawSetting("Rendering path:", settings.RenderingPathUsed);
DrawSetting("Color space:", settings.ColorSpaceUsed);
DrawSetting("Use multi-threaded rendering:", settings.UseMultithreadedRendering);
DrawSetting("Use GPU skinning:", settings.UseGPUSkinning);
DrawSetting("Enable Virtual Reality Support:", settings.EnableVirtualRealitySupport);
#if UNITY_5_2_AND_GREATER
DrawSetting("Graphics APIs Used:", settings.GraphicsAPIsUsed);
#endif
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
if (IsShowingMobileSettings)
{
DrawSetting("Default interface orientation:", settings.MobileDefaultOrientationUsed);
DrawSetting("Use OS screen auto-rotate:", settings.MobileEnableOSAutorotation);
DrawSetting("Auto-rotate to portrait:", settings.MobileEnableAutorotateToPortrait);
DrawSetting("Auto-rotate to reverse portrait:", settings.MobileEnableAutorotateToReversePortrait);
DrawSetting("Auto-rotate to landscape left:", settings.MobileEnableAutorotateToLandscapeLeft);
DrawSetting("Auto-rotate to landscape right:", settings.MobileEnableAutorotateToLandscapeRight);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingStandaloneSettings)
{
string standaloneScreenSize = settings.StandaloneDefaultScreenWidth + " x " + settings.StandaloneDefaultScreenHeight;
DrawSetting("Default screen size:", standaloneScreenSize);
DrawSetting("Resolution dialog:", settings.StandaloneResolutionDialogSettingUsed);
DrawSetting("Full-screen by default:", settings.StandaloneFullScreenByDefault);
DrawSetting("Resizable window:", settings.StandaloneEnableResizableWindow);
if (IsShowingWindowsDesktopSettings)
{
#if UNITY_5_2_AND_LESS
// not needed in Unity 5.3 since settings.GraphicsAPIsUsed shows better information
DrawSetting("Use Direct3D11 if available:", settings.WinUseDirect3D11IfAvailable);
#endif
DrawSetting("Direct3D9 Fullscreen Mode:", settings.WinDirect3D9FullscreenModeUsed);
#if UNITY_5
DrawSetting("Direct3D11 Fullscreen Mode:", settings.WinDirect3D11FullscreenModeUsed);
#endif
DrawSetting("Visible in background (for Fullscreen Windowed mode):", settings.VisibleInBackground);
}
else if (IsShowingMacSettings)
{
DrawSetting("Fullscreen mode:", settings.MacFullscreenModeUsed);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
DrawSetting("Allow OS switching between full-screen and window mode:", settings.StandaloneAllowFullScreenSwitch);
DrawSetting("Darken secondary monitors on full-screen:", settings.StandaloneCaptureSingleScreen);
DrawSetting("Force single instance:", settings.StandaloneForceSingleInstance);
DrawSetting("Stereoscopic Rendering:", settings.StandaloneUseStereoscopic3d);
DrawSetting("Supported aspect ratios:", settings.AspectRatiosAllowed);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
if (IsShowingWebPlayerSettings)
{
string webScreenSize = settings.WebPlayerDefaultScreenWidth + " x " + settings.WebPlayerDefaultScreenHeight;
DrawSetting("Screen size:", webScreenSize);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingWebGlSettings)
{
string webScreenSize = settings.WebPlayerDefaultScreenWidth + " x " + settings.WebPlayerDefaultScreenHeight;
DrawSetting("Screen size:", webScreenSize);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingiOSSettings)
{
#if !UNITY_5_3
// Unity 5.3 has a Screen.resolutions but I don't know which of those in the array would be the iOS target resolution
DrawSetting("Target resolution:", settings.iOSTargetResolution);
#endif
#if UNITY_5_1_AND_LESSER
// not used in Unity 5.2 since settings.GraphicsAPIsUsed shows better information
DrawSetting("Target graphics:", settings.iOSTargetGraphics);
#endif
DrawSetting("App icon pre-rendered:", settings.iOSIsIconPrerendered);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingAndroidSettings)
{
if (UnityMajorVersionUsedIsAtMost(4, buildReportToDisplay.UnityVersion))
{
DrawSetting("Use 24-bit depth buffer:", settings.AndroidUse24BitDepthBuffer);
}
if (UnityMajorVersionUsedIsAtLeast(5, buildReportToDisplay.UnityVersion))
{
DrawSetting("Disable depth and stencil buffers:", settings.AndroidDisableDepthAndStencilBuffers);
}
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
else if (IsShowingPS4Settings)
{
DrawSetting("Video out pixel format:", settings.PS4VideoOutPixelFormat);
DrawSetting("Video out resolution:", settings.PS4VideoOutResolution);
GUILayout.Space(SETTINGS_GROUP_MINOR_SPACING);
}
}
public abstract void DrawGUI(Rect position, BuildInfo buildReportToDisplay, AssetDependencies assetDependencies, out bool requestRepaint);
public void Initialize(BuildInfo buildInfo)
{
BuildInfo = buildInfo;
Text_CardDeckName.text = BuildInfo.BuildName;
Text_Count.text = BuildInfo.M_BuildCards.GetCardIDs().Count.ToString();
}
