Beispiel #1
0
        static void SortTextureData(BuildReportTool.SizePart[] assetList, BuildReportTool.TextureData textureData, BuildReportTool.AssetList.SortOrder sortOrder, Func <BuildReportTool.TextureData.Entry, int> func)
        {
            var textureEntries = textureData.GetTextureData();

            for (int n = 0; n < assetList.Length; ++n)
            {
                int intValue = 0;
                if (textureEntries.ContainsKey(assetList[n].Name))
                {
                    intValue = func(textureEntries[assetList[n].Name]);
                }

                assetList[n].SetIntAuxData(intValue);
            }

            SortByInt(assetList, sortOrder);
        }
Beispiel #2
0
        static void SortTextureData(BuildReportTool.SizePart[] assetList, BuildReportTool.TextureData textureData, BuildReportTool.AssetList.SortOrder sortOrder, Func <BuildReportTool.TextureData.Entry, string> func)
        {
            var textureEntries = textureData.GetTextureData();

            for (int n = 0; n < assetList.Length; ++n)
            {
                string textData = null;
                if (textureEntries.ContainsKey(assetList[n].Name))
                {
                    textData = func(textureEntries[assetList[n].Name]);
                }

                assetList[n].SetTextAuxData(textData);
            }

            SortByText(assetList, sortOrder);
        }
Beispiel #3
0
		public void Sort(BuildReportTool.TextureData textureData, BuildReportTool.TextureData.DataId sortType, SortOrder sortOrder, BuildReportTool.FileFilterGroup fileFilters)
		{
			_lastTextureSortType = sortType;
			_lastSortType = SortType.TextureData;
			_lastSortOrder = sortOrder;

			_hasListBeenSorted.Clear();

			_hasListBeenSorted.Add(fileFilters.SelectedFilterIdx);

			// sort only currently displayed list
			if (fileFilters.SelectedFilterIdx == -1)
			{
				AssetListUtility.SortAssetList(_all, textureData, sortType, sortOrder);
			}
			else
			{
				AssetListUtility.SortAssetList(_perCategory[fileFilters.SelectedFilterIdx], textureData, sortType, sortOrder);
			}
		}
Beispiel #4
0
        /// <summary>
        /// Create and save a Build Report. This is meant to be used for users who have a
        /// custom build script, or is automating a project build command from the command line.
        ///
        /// The Editor log needs to have build data for this to work,
        /// so only call this after <see cref="UnityEditor.BuildPipeline.BuildPlayer"/>.
        /// </summary>
        ///
        /// <remarks>
        /// <para>If your custom build scripts override the project's build settings,
        /// this overload allows you to explicitly specify the list of scenes, the build
        /// location, and the build target yourself.</para>
        ///
        /// <para>But if your build scripts didn't override the project's build settings,
        /// you can instead use <see cref="CreateReport(string)"/>.</para>
        /// </remarks>
        ///
        /// <param name="scenes">Which scenes were included in the build. Can be set to null
        /// so that BuildReportTool will just use UnityEditor.EditorBuildSettings.scenes instead.
        /// If you specified your own list of scenes when building, you should pass them here.</param>
        ///
        /// <param name="buildLocation">Absolute path where the build was saved to. Can be set to null so that
        /// BuildReportTool will just use Unity's <see cref="UnityEditor.EditorUserBuildSettings.GetBuildLocation"/>
        /// instead. If you specified your own build location, you should set it here.
        ///
        /// You can specify only the path to the build folder, but if there are multiple builds
        /// in that folder, it is best to specify the path to the build file itself
        /// (e.g. exe file for Windows Standalone, apk file for Android, etc.).</param>
        ///
        /// <param name="buildTarget">Type of build platform being made. You can just pass
        /// UnityEditor.EditorUserBuildSettings.activeBuildTarget if you didn't explicitly
        /// set this. If you specified your own build target, you should pass it here.</param>
        ///
        /// <param name="customEditorLogPath">If your Unity Editor log file is not in the
        /// default path, specify it here. Otherwise, leave this null so that BuildReportTool
        /// will just use the default location of the Editor.log file.</param>
        ///
        /// <returns>The full path and filename of the created Build Report XML file,
        /// or null if no Build Report was created.</returns>
        public static string CreateReport(string[] scenes, string buildLocation, BuildTarget buildTarget,
                                          string customEditorLogPath = null)
        {
            BuildReportTool.Util.BuildTargetOfLastBuild = buildTarget;

            var editorLogPathToUse = !string.IsNullOrEmpty(customEditorLogPath)
                                                         ? customEditorLogPath
                                                         : BuildReportTool.Util.UsedEditorLogPath;

            if (!DoesEditorLogHaveBuildInfo(editorLogPathToUse))
            {
                if (BuildReportTool.Util.IsDefaultEditorLogPathOverridden)
                {
                    Debug.LogWarning(string.Format(NO_BUILD_INFO_OVERRIDDEN_LOG_WARNING, editorLogPathToUse,
                                                   BuildReportTool.Options.FoundPathForSavedOptions));
                }
                else if (CheckIfUnityHasNoLogArgument())
                {
                    Debug.LogWarning(NO_BUILD_INFO_NO_LOG_WARNING);
                }
                else
                {
                    Debug.LogWarning(NO_BUILD_INFO_WARNING);
                }

                return(null);
            }

            var timeNow = System.DateTime.Now;

            _lastPathToBuiltProject = buildLocation;

            Init(true, ref _lastKnownBuildInfo, scenes);
            _lastKnownBuildInfo.TimeGot         = timeNow;
            _lastKnownBuildInfo.TimeGotReadable = timeNow.ToString(TIME_OF_BUILD_FORMAT);

            System.DateTime timeBuildStarted;
            if (BuildReportTool.Util.HasBuildTime())
            {
                timeBuildStarted = BuildReportTool.Util.LoadBuildTime();
            }
            else
            {
                timeBuildStarted = timeNow;
            }

            if (BuildReportTool.Options.CalculateAssetDependencies)
            {
                if (_lastKnownAssetDependencies == null)
                {
                    _lastKnownAssetDependencies = new BuildReportTool.AssetDependencies();
                }

                _lastKnownAssetDependencies.TimeGot = timeBuildStarted;
            }

            if (BuildReportTool.Options.CollectTextureImportSettings)
            {
                if (_lastKnownTextureData == null)
                {
                    _lastKnownTextureData = new BuildReportTool.TextureData();
                }

                _lastKnownTextureData.TimeGot = timeBuildStarted;
            }


            _lastEditorLogPath = editorLogPathToUse;

            if (BuildReportTool.Options.IncludeUnusedPrefabsInReportCreation)
            {
                RefreshListOfAllPrefabsUsedInAllScenesIncludedInBuild();
            }
            else
            {
                ClearListOfAllPrefabsUsedInAllScenes();
            }

            CommitAdditionalInfoToCache();

            CreateBuildReport(_lastKnownBuildInfo);

            var savedFilePath = OnFinishedGetValues(_lastKnownBuildInfo, _lastKnownAssetDependencies, _lastKnownTextureData);

            return(savedFilePath);
        }
Beispiel #5
0
        public static void SortAssetList(BuildReportTool.SizePart[] assetList, BuildReportTool.TextureData textureData, TextureData.DataId textureSortType, BuildReportTool.AssetList.SortOrder sortOrder)
        {
            switch (textureSortType)
            {
            case BuildReportTool.TextureData.DataId.TextureType:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.TextureType);
                break;

            case BuildReportTool.TextureData.DataId.IsSRGB:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.IsSRGB);
                break;

            case BuildReportTool.TextureData.DataId.AlphaSource:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.AlphaSource);
                break;

            case BuildReportTool.TextureData.DataId.AlphaIsTransparency:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.AlphaIsTransparency);
                break;

            case BuildReportTool.TextureData.DataId.IgnorePngGamma:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.IgnorePngGamma);
                break;

            case BuildReportTool.TextureData.DataId.NPotScale:
                SortNPotScale(assetList, textureData, sortOrder);
                break;

            case BuildReportTool.TextureData.DataId.IsReadable:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.IsReadable);
                break;

            case BuildReportTool.TextureData.DataId.MipMapGenerated:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.MipMapGenerated);
                break;

            case BuildReportTool.TextureData.DataId.MipMapFilter:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.MipMapFilter);
                break;

            case BuildReportTool.TextureData.DataId.StreamingMipMaps:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.StreamingMipMaps);
                break;

            case BuildReportTool.TextureData.DataId.BorderMipMaps:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.BorderMipMaps);
                break;

            case BuildReportTool.TextureData.DataId.PreserveCoverageMipMaps:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.PreserveCoverageMipMaps);
                break;

            case BuildReportTool.TextureData.DataId.FadeOutMipMaps:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.FadeOutMipMaps);
                break;

            case BuildReportTool.TextureData.DataId.SpriteImportMode:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.SpriteImportMode);
                break;

            case BuildReportTool.TextureData.DataId.SpritePackingTag:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.SpritePackingTag);
                break;

            case BuildReportTool.TextureData.DataId.SpritePixelsPerUnit:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.SpritePixelsPerUnit);
                break;

            case BuildReportTool.TextureData.DataId.QualifiesForSpritePacking:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.QualifiesForSpritePacking);
                break;

            case BuildReportTool.TextureData.DataId.WrapMode:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.WrapMode);
                break;

            case BuildReportTool.TextureData.DataId.WrapModeU:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.WrapModeU);
                break;

            case BuildReportTool.TextureData.DataId.WrapModeV:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.WrapModeV);
                break;

            case BuildReportTool.TextureData.DataId.WrapModeW:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.WrapModeW);
                break;

            case BuildReportTool.TextureData.DataId.FilterMode:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.FilterMode);
                break;

            case BuildReportTool.TextureData.DataId.AnisoLevel:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.AnisoLevel);
                break;

            case BuildReportTool.TextureData.DataId.MaxTextureSize:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.GetShownMaxTextureSize());
                break;

            case BuildReportTool.TextureData.DataId.TextureResizeAlgorithm:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.GetShownTextureResizeAlgorithm());
                break;

            case BuildReportTool.TextureData.DataId.TextureFormat:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.GetShownTextureFormat());
                break;

            case BuildReportTool.TextureData.DataId.CompressionType:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.GetShownCompressionType());
                break;

            case BuildReportTool.TextureData.DataId.CompressionIsCrunched:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.GetShownCompressionIsCrunched());
                break;

            case BuildReportTool.TextureData.DataId.CompressionQuality:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.GetShownCompressionQuality());
                break;

            case BuildReportTool.TextureData.DataId.ImportedWidthAndHeight:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.GetImportedPixelCount());
                break;

            case BuildReportTool.TextureData.DataId.RealWidthAndHeight:
                SortTextureData(assetList, textureData, sortOrder, entry => entry.GetRealPixelCount());
                break;
            }
        }
Beispiel #6
0
        // NPotScale sort is special: we want the "None (Not Power of 2)" values to go at top, ignoring alphabetical order for that special value
        static void SortNPotScale(BuildReportTool.SizePart[] assetList, BuildReportTool.TextureData textureData, BuildReportTool.AssetList.SortOrder sortOrder)
        {
            var textureEntries = textureData.GetTextureData();

            for (int n = 0; n < assetList.Length; ++n)
            {
                string textData = null;
                if (textureEntries.ContainsKey(assetList[n].Name))
                {
                    textData = textureEntries[assetList[n].Name].NPotScale;
                }

                assetList[n].SetTextAuxData(textData);
            }

            if (sortOrder == BuildReportTool.AssetList.SortOrder.Descending)
            {
                Array.Sort(assetList, delegate(BuildReportTool.SizePart entry1, BuildReportTool.SizePart entry2)
                {
                    string nPotScale1 = entry1.GetTextAuxData();
                    string nPotScale2 = entry2.GetTextAuxData();

                    // put non-power-of-2 at top
                    bool nPotScale1IsNoneNot = nPotScale1 == BuildReportTool.TextureData.NPOT_SCALE_NONE_NOT_POT;
                    bool nPotScale2IsNoneNot = nPotScale2 == BuildReportTool.TextureData.NPOT_SCALE_NONE_NOT_POT;
                    if (nPotScale1IsNoneNot && !nPotScale2IsNoneNot)
                    {
                        return(-1);
                    }
                    if (!nPotScale1IsNoneNot && nPotScale2IsNoneNot)
                    {
                        return(1);
                    }

                    // at this point, entry1 and entry 2 are not non-power-of-2 (or both of them are), so compare them as usual
                    int sortTextureTypeResult = string.Compare(nPotScale1, nPotScale2, StringComparison.OrdinalIgnoreCase);
                    if (sortTextureTypeResult != 0)
                    {
                        return(sortTextureTypeResult);
                    }

                    // same nPotScale type
                    // sort by asset size for assets with same nPotScale types
                    if (entry1.UsableSize > entry2.UsableSize)
                    {
                        return(-1);
                    }
                    if (entry1.UsableSize < entry2.UsableSize)
                    {
                        return(1);
                    }

                    // same size
                    // sort by asset name for assets with same sizes
                    return(SortByAssetNameDescending(entry1, entry2));
                });
            }
            else
            {
                Array.Sort(assetList, delegate(BuildReportTool.SizePart entry1, BuildReportTool.SizePart entry2)
                {
                    string nPotScale1 = entry1.GetTextAuxData();
                    string nPotScale2 = entry2.GetTextAuxData();

                    // put non-power-of-2 at bottom
                    bool nPotScale1IsNoneNot = nPotScale1 == BuildReportTool.TextureData.NPOT_SCALE_NONE_NOT_POT;
                    bool nPotScale2IsNoneNot = nPotScale2 == BuildReportTool.TextureData.NPOT_SCALE_NONE_NOT_POT;
                    if (nPotScale1IsNoneNot && !nPotScale2IsNoneNot)
                    {
                        return(1);
                    }
                    if (!nPotScale1IsNoneNot && nPotScale2IsNoneNot)
                    {
                        return(-1);
                    }

                    // at this point, entry1 and entry 2 are not non-power-of-2 (or both of them are), so compare them as usual
                    int sortTextureTypeResult = string.Compare(nPotScale2, nPotScale1, StringComparison.OrdinalIgnoreCase);
                    if (sortTextureTypeResult != 0)
                    {
                        return(sortTextureTypeResult);
                    }

                    // same nPotScale type
                    // sort by asset size for assets with same nPotScale types
                    if (entry1.UsableSize > entry2.UsableSize)
                    {
                        return(1);
                    }
                    if (entry1.UsableSize < entry2.UsableSize)
                    {
                        return(-1);
                    }

                    // same size
                    // sort by asset name for assets with same sizes
                    return(SortByAssetNameAscending(entry1, entry2));
                });
            }
        }