Exemplo n.º 1
0
        // Start is called before the first frame update
        /// <summary>
        /// 创建寻找指导名字的group
        /// 当autoCreate为true时候不存在就创建
        /// </summary>
        /// <param name="groupName"></param>
        /// <param name="Create"></param>
        /// <returns></returns>
        public static AddressableAssetGroup FindGroup(string groupName, AddressableAssetGroupTemplate groupTemplate = null)
        {
            var setting = LoadAASSetting();
            var group   = setting.FindGroup(groupName);

            if (group == null && groupTemplate != null)
            {
                group = setting.CreateGroup(groupName, false, false, true, null, groupTemplate.GetTypes());
                groupTemplate.ApplyToAddressableAssetGroup(group);
            }
            return(group);
        }
Exemplo n.º 2
0
    /// <summary>
    /// 创新新的资源条目,并将添加到新的组中
    /// </summary>
    /// <param name="setting"></param>
    /// <param name="groupTemplete"></param>
    /// <param name="assetPath"></param>
    /// <returns></returns>
    static AddressableAssetEntry CreateEntryToNewGroup(AddressableAssetSettings setting, AddressableAssetGroupTemplate groupTemplete, string assetPath)
    {
        string guid  = AssetDatabase.AssetPathToGUID(assetPath);
        var    entry = setting.FindAssetEntry(guid);

        if (entry != null)
        {
            return(entry);
        }

        var newGroup = setting.CreateGroup(assetPath, false, false, true, null, groupTemplete.GetTypes());

        groupTemplete.ApplyToAddressableAssetGroup(newGroup);

        var entryToAdd = setting.CreateOrMoveEntry(guid, newGroup, false, false);

        newGroup.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entryToAdd, false, true);
        setting.SetDirty(AddressableAssetSettings.ModificationEvent.EntryMoved, entryToAdd, true, false);

        return(entryToAdd);
    }
Exemplo n.º 3
0
        public override void FixIssues(AddressableAssetSettings settings)
        {
            // Load template used for creating new groups

            var groupTemplates = settings.GroupTemplateObjects;
            AddressableAssetGroupTemplate foundTemplate = null;

            foreach (var template in groupTemplates)
            {
                if (template.name == templateToUse)
                {
                    foundTemplate = template as AddressableAssetGroupTemplate;
                    break;
                }
            }

            if (foundTemplate == null)
            {
                Debug.Log("Group template \"" + templateToUse + "\" not found. Aborting!");
                return;
            }

            // Create groups

            foreach (var groupName in groupsToCreate)
            {
                // I don't know enough about schemas, so schemasToCopy is set to null here.
                AddressableAssetGroup newGroup = settings.CreateGroup(groupName, false, false, true, null, foundTemplate.GetTypes());
                foundTemplate.ApplyToAddressableAssetGroup(newGroup);
            }

            // Remove groups

            foreach (var groupName in groupsToRemove)
            {
                foreach (var group in settings.groups)
                {
                    if (group.name == groupName)
                    {
                        settings.RemoveGroup(group);
                        break;
                    }
                }
            }

            // Collect current group names

            Dictionary <string, AddressableAssetGroup> groups = new Dictionary <string, AddressableAssetGroup>();

            foreach (var group in settings.groups)
            {
                groups.Add(group.name, group);
            }

            // Create and remove assets

            foreach (var action in assetActions)
            {
                if (!groups.ContainsKey(action.inGroup))
                {
                    continue;
                }

                if (action.create)
                {
                    AddressableAssetEntry entry = settings.CreateOrMoveEntry(action.assetGuid, groups[action.inGroup]);
                    entry.SetAddress(action.addressablePath);
                }
                else
                {
                    AddressableAssetEntry entry = settings.FindAssetEntry(action.assetGuid);
                    if (entry != null)
                    {
                        settings.RemoveAssetEntry(action.assetGuid);
                    }
                    else
                    {
                        Debug.Log("Asset guid didn't produce an entry: " + action.assetGuid);
                    }
                }
            }

            ClearAnalysis();
            ClearOurData();
        }
        void DrawSingleGroup()
        {
            EditorGUILayout.LabelField("Group Template Description");
            m_AddressableAssetGroupTarget.Description = EditorGUILayout.TextArea(m_AddressableAssetGroupTarget.Description);

            int objectCount = m_AddressableAssetGroupTarget.SchemaObjects.Count;

            if (m_FoldoutState == null || m_FoldoutState.Length != objectCount)
            {
                m_FoldoutState = new bool[objectCount];
            }

            for (int i = 0; i < objectCount; i++)
            {
                var schema       = m_AddressableAssetGroupTarget.SchemaObjects[i];
                int currentIndex = i;

                DrawDivider();
                EditorGUILayout.BeginHorizontal();
                m_FoldoutState[i] = EditorGUILayout.Foldout(m_FoldoutState[i], AddressableAssetUtility.GetCachedTypeDisplayName(m_AddressableAssetGroupTarget.SchemaObjects[i].GetType()));

                GUILayout.FlexibleSpace();
                GUIStyle gearIconStyle = UnityEngine.GUI.skin.FindStyle("IconButton") ?? EditorGUIUtility.GetBuiltinSkin(EditorSkin.Inspector).FindStyle("IconButton");

                if (EditorGUILayout.DropdownButton(EditorGUIUtility.IconContent("_Popup"), FocusType.Keyboard, gearIconStyle))
                {
                    var menu = new GenericMenu();
                    menu.AddItem(AddressableAssetGroup.RemoveSchemaContent, false, () =>
                    {
                        var schemaName = AddressableAssetUtility.GetCachedTypeDisplayName(m_AddressableAssetGroupTarget.SchemaObjects[currentIndex].GetType());
                        if (EditorUtility.DisplayDialog("Remove selected schema?", "Are you sure you want to remove " + schemaName + " schema?\n\nYou cannot undo this action.", "Yes", "No"))
                        {
                            m_AddressableAssetGroupTarget.RemoveSchema(currentIndex);
                            var newFoldoutstate = new bool[objectCount - 1];
                            for (int j = 0; j < newFoldoutstate.Length; j++)
                            {
                                if (j < i)
                                {
                                    newFoldoutstate[j] = m_FoldoutState[j];
                                }
                                else
                                {
                                    newFoldoutstate[j] = m_FoldoutState[currentIndex + 1];
                                }
                            }

                            m_FoldoutState = newFoldoutstate;
                        }
                    });
                    menu.AddItem(AddressableAssetGroup.MoveSchemaUpContent, false, () =>
                    {
                        if (currentIndex > 0)
                        {
                            m_AddressableAssetGroupTarget.SchemaObjects[currentIndex]     = m_AddressableAssetGroupTarget.SchemaObjects[currentIndex - 1];
                            m_AddressableAssetGroupTarget.SchemaObjects[currentIndex - 1] = schema;
                            return;
                        }
                    });
                    menu.AddItem(AddressableAssetGroup.MoveSchemaDownContent, false, () =>
                    {
                        if (currentIndex < m_AddressableAssetGroupTarget.SchemaObjects.Count - 1)
                        {
                            m_AddressableAssetGroupTarget.SchemaObjects[currentIndex]     = m_AddressableAssetGroupTarget.SchemaObjects[currentIndex + 1];
                            m_AddressableAssetGroupTarget.SchemaObjects[currentIndex + 1] = schema;
                            return;
                        }
                    });
                    menu.AddSeparator("");
                    menu.AddItem(AddressableAssetGroup.ExpandSchemaContent, false, () =>
                    {
                        m_FoldoutState[currentIndex] = true;
                        m_AddressableAssetGroupTarget.SchemaObjects[currentIndex].ShowAllProperties();
                    });
                    menu.ShowAsContext();
                }

                EditorGUILayout.EndHorizontal();

                if (m_FoldoutState[i])
                {
                    try
                    {
                        EditorGUI.indentLevel++;
                        m_AddressableAssetGroupTarget.SchemaObjects[i].OnGUI();
                        EditorGUI.indentLevel--;
                    }
                    catch (Exception se)
                    {
                        Debug.LogException(se);
                    }
                }
            }

            DrawDivider();
            EditorGUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();
            GUIStyle addSchemaButton = new GUIStyle(UnityEngine.GUI.skin.button);

            addSchemaButton.fontSize    = 12;
            addSchemaButton.fixedWidth  = 225;
            addSchemaButton.fixedHeight = 22;

            if (EditorGUILayout.DropdownButton(new GUIContent("Add Schema", "Add new schema to this group."), FocusType.Keyboard, addSchemaButton))
            {
                var menu = new GenericMenu();
                for (int i = 0; i < m_SchemaTypes.Count; i++)
                {
                    var type = m_SchemaTypes[i];

                    if (Array.IndexOf(m_AddressableAssetGroupTarget.GetTypes(), type) == -1)
                    {
                        menu.AddItem(new GUIContent(AddressableAssetUtility.GetCachedTypeDisplayName(type), ""), false, () => OnAddSchema(type));
                    }
                    else
                    {
                        menu.AddDisabledItem(new GUIContent(AddressableAssetUtility.GetCachedTypeDisplayName(type), ""), true);
                    }
                }

                menu.ShowAsContext();
            }

            GUILayout.FlexibleSpace();
            EditorGUILayout.EndHorizontal();
        }