Ejemplo n.º 1
0
        private bool FilterAddressData(PackerAssetData assetData)
        {
            if (string.IsNullOrEmpty(searchText))
            {
                return(true);
            }

            if (searchCategory == SearchCategory.All || searchCategory == SearchCategory.AssetAddress)
            {
                if (!string.IsNullOrEmpty(assetData.Address) &&
                    assetData.Address.IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0)
                {
                    return(true);
                }
            }
            if (searchCategory == SearchCategory.All || searchCategory == SearchCategory.AssetPath)
            {
                if (!string.IsNullOrEmpty(assetData.Path) &&
                    assetData.Path.IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0)
                {
                    return(true);
                }
            }
            if (searchCategory == SearchCategory.All || searchCategory == SearchCategory.AssetLabels)
            {
                string label = string.Join(",", assetData.Labels);
                if (!string.IsNullOrEmpty(label) &&
                    label.IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0)
                {
                    return(true);
                }
            }

            return(false);
        }
Ejemplo n.º 2
0
        private void SetTreeModel()
        {
            TreeModel <TreeElementWithData <AssetPackerTreeData> > treeModel = assetPackerTreeView.treeModel;
            TreeElementWithData <AssetPackerTreeData> treeModelRoot          = treeModel.root;

            treeModelRoot.children?.Clear();

            int id = 1;

            for (int i = 0; i < packerData.groupDatas.Count; ++i)
            {
                var groupData = packerData.groupDatas[i];
                if (FilterGroupData(groupData))
                {
                    AssetPackerTreeData groupTreeData = new AssetPackerTreeData();
                    groupTreeData.GroupIndex = i;

                    TreeElementWithData <AssetPackerTreeData> groupElementData = new TreeElementWithData <AssetPackerTreeData>(groupTreeData, "", 0, id);
                    treeModel.AddElement(groupElementData, treeModelRoot, treeModelRoot.hasChildren ? treeModelRoot.children.Count : 0);
                    id++;

                    for (int j = 0; j < groupData.bundleDatas.Count; j++)
                    {
                        PackerBundleData bundleData = groupData.bundleDatas[j];
                        if (FilterBundleData(bundleData))
                        {
                            AssetPackerTreeData bundleTreeData = new AssetPackerTreeData();
                            bundleTreeData.GroupIndex  = i;
                            bundleTreeData.BundleIndex = j;

                            TreeElementWithData <AssetPackerTreeData> bundleElementData = new TreeElementWithData <AssetPackerTreeData>(bundleTreeData, "", 0, id);
                            treeModel.AddElement(bundleElementData, groupElementData, groupElementData.hasChildren ? groupElementData.children.Count : 0);
                            id++;

                            for (int k = 0; k < bundleData.assetDatas.Count; k++)
                            {
                                PackerAssetData assetData = bundleData.assetDatas[k];
                                if (FilterAddressData(assetData))
                                {
                                    AssetPackerTreeData assetTreeData = new AssetPackerTreeData();
                                    assetTreeData.GroupIndex  = i;
                                    assetTreeData.BundleIndex = j;
                                    assetTreeData.AssetIndex  = k;

                                    TreeElementWithData <AssetPackerTreeData> assetElementData = new TreeElementWithData <AssetPackerTreeData>(assetTreeData, "", 0, id);
                                    treeModel.AddElement(assetElementData, bundleElementData, bundleElementData.hasChildren ? bundleElementData.children.Count : 0);
                                    id++;
                                }
                            }
                        }
                    }
                }
            }
        }
        private void DrawAddressData(Rect contentRect, PackerAssetData assetData)
        {
            EGUI.DrawAreaLine(contentRect, Color.black);

            Rect pingBtnRect = new Rect(contentRect.x + contentRect.width - contentRect.height * 2, contentRect.y, contentRect.height * 2, contentRect.height);

            if (GUI.Button(pingBtnRect, "Ping"))
            {
                SelectionUtility.PingObject(assetData.Path);
            }

            Rect ValueRect = new Rect(contentRect.x, contentRect.y, contentRect.width - contentRect.height * 2, contentRect.height);

            Rect drawRect = new Rect(ValueRect.x, ValueRect.y, ValueRect.width * 0.5f, ValueRect.height * 0.5f);

            EGUI.BeginLabelWidth(80);
            {
                EditorGUI.TextField(drawRect, "path", assetData.Path);
            }
            EGUI.EndLableWidth();

            drawRect = new Rect(ValueRect.x, ValueRect.y + drawRect.height, ValueRect.width * 0.5f, ValueRect.height * 0.5f);
            EGUI.BeginLabelWidth(80);
            {
                EditorGUI.TextField(drawRect, "address", assetData.Address);
            }
            EGUI.EndLableWidth();

            drawRect = new Rect(ValueRect.x + ValueRect.width * 0.5f, ValueRect.y, ValueRect.width * 0.5f, ValueRect.height * 0.5f);
            EGUI.BeginLabelWidth(80);
            {
                EditorGUI.TextField(drawRect, "labels", string.Join(",", assetData.Labels));
            }
            EGUI.EndLableWidth();

            drawRect = new Rect(ValueRect.x + ValueRect.width * 0.5f, ValueRect.y + drawRect.height, ValueRect.width * 0.5f, ValueRect.height * 0.5f);
            EGUI.BeginLabelWidth(80);
            {
            }
            EGUI.EndLableWidth();
            //if (Window.IsAddressRepeated(assetData.Address, out List<PackerBundleData> datas))
            //{
            //    if (GUI.Button(drawRect,addressRepeatContent))
            //    {
            //        AssetAddressRepeatPopupContent content = new AssetAddressRepeatPopupContent()
            //        {
            //            RepeatAddressDatas = datas.ToArray(),
            //        };
            //        PopupWindow.Show(drawRect, content);
            //    }
            //}
        }
        public static PackerData GetPackerData()
        {
            AssetGroupCreater[] groups  = AssetDatabaseUtility.FindInstances <AssetGroupCreater>();
            List <AssetResult>  results = new List <AssetResult>();

            foreach (var group in groups)
            {
                results.AddRange(group.GetResults());
            }

            PackerData packerData = new PackerData();

            var groupNames = results.GroupBy((result) => result.GroupName).ToList();

            foreach (var gn in groupNames)
            {
                PackerGroupData groupData = new PackerGroupData();
                groupData.Name = gn.Key;
                packerData.groupDatas.Add(groupData);

                var bundleNames = gn.GroupBy((result) => result.Bundle).ToList();
                foreach (var bn in bundleNames)
                {
                    PackerBundleData bundleData = new PackerBundleData();
                    bundleData.Path = bn.Key;
                    groupData.bundleDatas.Add(bundleData);

                    foreach (var ad in bn)
                    {
                        PackerAssetData assetData = new PackerAssetData();
                        assetData.Address     = ad.Address;
                        assetData.Path        = ad.Path;
                        assetData.IsMainAsset = ad.IsMainAsset;
                        assetData.IsScene     = ad.IsScene;
                        assetData.Labels      = ad.Labels;

                        bundleData.assetDatas.Add(assetData);
                    }
                }
            }

            return(packerData);
        }