예제 #1
0
    void OnEnable()
    {
        CharacterVariant variant = target as CharacterVariant;

        for (int i = 0; i < variant.Partitions.Count; i++)
        {
            string assetPath = PartitionAssetManager.Instance.GetAssetPath(variant.Partitions[i].AssetName);
            if (string.IsNullOrEmpty(assetPath))
            {
                continue;
            }
            PartitionInfo partition = variant.Partitions[i];
            partition.AssetObject = AssetDatabase.LoadAssetAtPath(assetPath, typeof(GameObject)) as GameObject;
            variant.Partitions[i] = partition;
            PartitionAssetManager.Instance.RegisterAssetObject(partition.AssetName, partition.AssetObject);

            CharacterPartitionLink link = partition.AssetObject.GetComponent <CharacterPartitionLink>();
            if (link != null)
            {
                for (int j = 0; j < link.LinkedPartitions.Count; j++)
                {
                    string linkedAssetPath = PartitionAssetManager.Instance.GetAssetPath(link.LinkedPartitions[j].AssetName);
                    if (string.IsNullOrEmpty(linkedAssetPath))
                    {
                        continue;
                    }
                    PartitionInfo linkedPartition = link.LinkedPartitions[j];
                    linkedPartition.AssetObject = AssetDatabase.LoadAssetAtPath(linkedAssetPath, typeof(GameObject)) as GameObject;
                    link.LinkedPartitions[j]    = linkedPartition;
                    PartitionAssetManager.Instance.RegisterAssetObject(linkedPartition.AssetName, linkedPartition.AssetObject);
                }
            }
        }
    }
예제 #2
0
    void OnEnable()
    {
        CharacterPartitionLink link = target as CharacterPartitionLink;

        for (int i = 0; i < link.LinkedPartitions.Count; i++)
        {
            string assetPath = PartitionAssetManager.Instance.GetAssetPath(link.LinkedPartitions[i].AssetName);
            if (string.IsNullOrEmpty(assetPath))
            {
                continue;
            }
            PartitionInfo partition = link.LinkedPartitions[i];
            partition.AssetObject    = AssetDatabase.LoadAssetAtPath(assetPath, typeof(GameObject)) as GameObject;
            link.LinkedPartitions[i] = partition;
        }
    }
예제 #3
0
    void DrawPartition(int index, ref bool delete)
    {
        CharacterPartitionLink link = target as CharacterPartitionLink;
        string prefsKey             = string.Format("CharacterPartitionLink_Partition_{0}", index);
        bool   view = EditorPrefs.GetBool(prefsKey, true);

        PartitionInfo partition = link.LinkedPartitions[index];

        GUILayout.BeginHorizontal();
        {
            GUILayout.Space(12);
            view = EditorGUILayout.Foldout(view, partition.Name);

            if (GUILayout.Button("X", GUILayout.Width(20)))
            {
                delete = true;
            }
        }
        GUILayout.EndHorizontal();
        EditorPrefs.SetBool(prefsKey, view);

        if (view)
        {
            partition.Name = EditorGUILayout.TextField("Name", partition.Name);
            GUILayout.BeginHorizontal();
            {
                GUI.enabled         = false;
                partition.AssetName = EditorGUILayout.TextField("Asset Name", partition.AssetName);
                GUI.enabled         = true;

                partition.AssetObject = EditorGUILayout.ObjectField(partition.AssetObject, typeof(GameObject), false, GUILayout.Width(160)) as GameObject;
                if (partition.AssetObject != null)
                {
                    partition.AssetName = partition.AssetObject.name;
                }
            }
            GUILayout.EndHorizontal();
            link.LinkedPartitions[index] = partition;
        }
    }
예제 #4
0
    /// <summary>
    /// 部件加载成完
    /// </summary>
    /// <param name="assetName">资源名称</param>
    /// <param name="partitionObj">部件数据对象</param>
    /// <param name="isSuccess">是否成功</param>
    void OnOTALoaded(string assetName, GameObject partitionObj, bool isSuccess)
    {
        Loaded.Add(assetName);
        List <PartitionInfo> linkedPartionInfos = null;

        if (isSuccess && partitionObj != null)
        {
            //从代码上看~现在应该是没有这个组件再挂载在部件上面了,要不就成了部件上面再加载部件的信息
            CharacterPartitionLink partitionLink = partitionObj.GetComponent <CharacterPartitionLink>();
            if (partitionLink != null)
            {
                linkedPartionInfos = new List <PartitionInfo>();
                for (int i = partitionLink.LinkedPartitions.Count - 1; i >= 0; i--)
                {
                    PartitionInfo info = partitionLink.LinkedPartitions[i];
                    linkedPartionInfos.Add(info);
                }
            }
        }

        if (_onAssetLoaded != null)
        {
            _onAssetLoaded(_name, assetName, partitionObj, isSuccess, false);
        }

        //要是部件信息存在的情况,就加载一个一个加载需要的部件,目前上看~是不会运行这段代码
        if (linkedPartionInfos != null)
        {
            for (int i = linkedPartionInfos.Count - 1; i >= 0; i--)
            {
                PartitionInfo info = linkedPartionInfos[i];
                // GM.AssetManager.GetAsset<GameObject>(info.AssetName, OnLinkedAssetLoaded, _target, true);
                EB.Assets.LoadAsyncAndInit <GameObject>(info.AssetName, OnLinkedAssetLoaded, _target);
            }
        }
    }
예제 #5
0
    public void PreviewCharacter(List <PartitionInfo> infos)
    {
        Transform[] skeletonBones = gameObject.GetComponentsInChildren <Transform>();
        int         skeletonCount = skeletonBones.Length;

        m_SkeletonBonesDic.Clear();
        for (int i = 0; i < skeletonCount; i++)
        {
            m_SkeletonBonesDic.Add(skeletonBones[i].name, skeletonBones[i]);
        }

        Transform prevTransform = gameObject.transform.Find(PreviewTransformName);

        if (prevTransform != null)
        {
            GameObject.DestroyImmediate(prevTransform.gameObject);
        }

        for (int i = 0; i < infos.Count; i++)
        {
            PartitionInfo   info      = infos[i];
            PartitionObject partition = new PartitionObject();
            partition.Name      = info.Name;
            partition.AssetName = info.AssetName;
            m_Partitions.Add(info.Name, partition);
            if (info.AssetObject == null)
            {
                info.AssetObject = PartitionAssetManager.Instance.GetAssetObject(info.AssetName);

                if (info.AssetObject == null)
                {
                    string assetPath = PartitionAssetManager.Instance.GetAssetPath(info.AssetName);
                    if (!string.IsNullOrEmpty(assetPath))
                    {
                        info.AssetObject = AssetDatabase.LoadAssetAtPath(assetPath, typeof(GameObject)) as GameObject;
                        if (info.AssetObject != null)
                        {
                            PartitionAssetManager.Instance.RegisterAssetObject(info.AssetName, info.AssetObject);
                        }
                    }
                }
            }
            GameObject           partitionObject      = GameObject.Instantiate(info.AssetObject) as GameObject;
            List <PartitionInfo> linkedPartitionInfos = null;

            CharacterPartitionLink partitionLink = partitionObject.GetComponent <CharacterPartitionLink>();

            if (partitionLink != null)
            {
                linkedPartitionInfos = new List <PartitionInfo>();
                foreach (PartitionInfo linkedInfo in partitionLink.LinkedPartitions)
                {
                    linkedPartitionInfos.Add(linkedInfo);
                }
            }

            UpdatePartition(info.Name, info.AssetName, partitionObject, false);

            if (linkedPartitionInfos != null)
            {
                for (int j = 0; j < linkedPartitionInfos.Count; j++)
                {
                    PartitionInfo linkedInfo = linkedPartitionInfos[j];
                    if (linkedInfo.AssetObject == null)
                    {
                        linkedInfo.AssetObject = PartitionAssetManager.Instance.GetAssetObject(linkedInfo.AssetName);
                    }
                    GameObject linkedObj = GameObject.Instantiate(linkedInfo.AssetObject) as GameObject;
                    UpdatePartition(info.Name, linkedInfo.AssetName, linkedObj, true);
                }
            }
        }
    }
예제 #6
0
    void DrawLinkedPartitionList()
    {
        CharacterPartitionLink link = target as CharacterPartitionLink;

        if (NGUIEditorTools.DrawHeader(string.Format("Linked Partition List ({0})", link.LinkedPartitions.Count), "CharacterPartitionLink_Partitions"))
        {
            NGUIEditorTools.BeginContents();
            {
                bool delete = false;
                for (int i = 0; i < link.LinkedPartitions.Count; i++)
                {
                    if (i > 0)
                    {
                        GUILayout.Space(5);
                    }


                    NGUIEditorTools.BeginContents();
                    {
                        DrawPartition(i, ref delete);
                    }
                    NGUIEditorTools.EndContents();

                    if (delete)
                    {
                        link.LinkedPartitions.RemoveAt(i);
                        break;
                    }
                }

                if (GUILayout.Button("Add New Partition"))
                {
                    PartitionInfo newPartition = new PartitionInfo();
                    int           count        = 1;
                    string        name         = string.Format("Partition_{0}", count);
                    while (true)
                    {
                        bool nameExisted = false;
                        foreach (PartitionInfo partition in link.LinkedPartitions)
                        {
                            if (partition.Name == name)
                            {
                                nameExisted = true;
                                break;
                            }
                        }
                        if (nameExisted)
                        {
                            count++;
                            name = string.Format("Partition_{0}", count);
                        }
                        else
                        {
                            break;
                        }
                    }

                    newPartition.Name = name;
                    link.LinkedPartitions.Add(newPartition);
                }
            }
            NGUIEditorTools.EndContents();
        }
    }