GHZMRSupportXR/Assets/XRToolkit/ArtShow/Scripts/Art/ArtHandler.cs

using System;
using System.Collections;
using System.Collections.Generic;
using TriLibCore;
using UnityEngine;
using XRTool.Util;

namespace ShadowStudio.Model
{
    /// <summary>
    /// 资源的处理类
    /// 相同资源只会创建一个实例
    /// </summary>
    public class ArtHandler : ArtInstance, ArtPlay
    {
        //public ArtHandler() {
        //    Debug.Log("ArtHandler:" + UnityUtil.CurTimeString);
        //}
        private ArtInstanceHandler instancer;
        private ArtPlay artDisPlay;
        private ArtInfo info;

        public ArtInstanceHandler Instancer { get => instancer; set => instancer = value; }
        public ArtPlay ArtDisPlay { get => artDisPlay; set => artDisPlay = value; }
        public float DownProcess { get => Instancer.DownProcess; set => Instancer.DownProcess = value; }

        public event Action<ArtPlay> OnCreateArt;
        private Texture artIcon;
        //private Action<float> loadProcess;
        //private Action<UnityEngine.Object> artLoaded;
        /// <summary>
        /// 初始化资源
        /// </summary>
        /// <param name="info"></param>
        public virtual void SetData(ArtInfo info, string containerName = "")
        {
            if (info != null)
            {
                this.info = info;
                if (info.InstaceType == InstaceType.ResourceLoad)
                {
                    Instancer = new ResourcesHandler();
                }
                else if (info.InstaceType == InstaceType.UnityBase)
                {
                    Instancer = new UnityBaseHandler();
                }
                else if (info.InstaceType == InstaceType.References)
                {
                    Instancer = new ReferencesLoadHandler();
                }
                else if (info.InstaceType == InstaceType.AssetBundle)
                {
                    Instancer = new ExtralLoadHandler();
                }
                else if (info.InstaceType == InstaceType.ExtralURLDownload)
                {
                    Instancer = new ExtralLoadHandler();
                }
                else if (info.InstaceType == InstaceType.LocalPath)
                {
                    Instancer = new ExtralLoadHandler();
                }
                if (Instancer != null)
                {
                    Instancer.SetData(info);
                }

                if (info.ArtType == ArtType.Model)
                {
                    ArtDisPlay = new ModelPlayer();
                }
                else if (info.ArtType == ArtType.WorldDlg)
                {
                    ArtDisPlay = new WorldDlgPlayer();
                }
                else if (info.ArtType == ArtType.Image)
                {
                    ArtDisPlay = new PictruePlayer();
                }
                else if (info.ArtType == ArtType.Movies)
                {
                    ArtDisPlay = new ArtVideoPlayer();
                }
                else if (info.ArtType == ArtType.Prefab)
                {
                    ArtDisPlay = new PrefabPlayer(containerName);
                }
                else if (info.ArtType == ArtType.Model2D)
                {
                    ArtDisPlay = new Model2DPlayer();
                }
                if (ArtDisPlay != null)
                {
                    ArtDisPlay.SetData(info);
                }
            }
        }
        /// <summary>
        /// 同步加载资源
        /// </summary>
        /// <returns></returns>
        public virtual UnityEngine.Object LoadArt()
        {
            if (Instancer != null && ArtDisPlay != null)
            {
                if (IsNeedLoad())
                {
                    return Instancer.LoadArt();
                }
            }
            return null;
        }
        /// <summary>
        /// 异步加载资源
        /// </summary>
        /// <param name="path"></param>
        /// <param name="process"></param>
        /// <param name="loaded"></param>
        public virtual void LoadArtAsyn(string path, Action<float> process, Action<UnityEngine.Object> loaded)
        {
            if (Instancer != null && ArtDisPlay != null)
            {
                if (IsNeedLoad())
                {
                    Instancer.LoadArtAsyn(path, process, loaded);
                    return;
                }
                process?.Invoke(1);
                loaded?.Invoke(null);
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public virtual UnityEngine.Object InstanceArt()
        {
            if (Instancer != null && ArtDisPlay != null)
            {
                if (IsNeedInstance())
                {
                    return Instancer.InstanceArt();
                }
            }
            return null;
        }
        /// <summary>
        /// 添加到容器中
        /// </summary>
        /// <param name="obj"></param>
        public void AddToNode(UnityEngine.Object obj)
        {
            if (ArtDisPlay != null)
            {
                ArtDisPlay.AddToNode(obj);
            }
        }
        /// <summary>
        /// 获取图标
        /// </summary>
        /// <returns></returns>
        public Texture GetIcon()
        {
            if (artIcon)
            {
                return artIcon;
            }
            if ((info.InstaceType == InstaceType.References || info.InstaceType == InstaceType.ResourceLoad ||
                    info.InstaceType == InstaceType.UnityBase) && Instancer != null)
            {
                if (info.ArtType == ArtType.Image)
                {
                    var tex = Instancer.LoadArt();
                    return artIcon = (tex as Texture);
                }
                else if (info.ArtType == ArtType.Movies)
                {
                    return artIcon = Instancer.GetIcon();
                }
                else
                {
                    return artIcon = Instancer.GetIcon();
                }
            }
            return artIcon;
        }
        /// <summary>
        /// 获取缩略图
        /// </summary>
        /// <param name="loadTex"></param>
        public void GetIcon(Action<Texture> loadTex)
        {
            if (artIcon)
            {
                loadTex?.Invoke(artIcon);
                return;
            }
            Instancer.GetIcon(loadTex);
            loadTex += (tex) => { artIcon = tex; };
        }
        /// <summary>
        /// 创建对应的组件
        /// </summary>
        /// <returns></returns>
        public ArtComponent InstanceComponent()
        {
            if (Instancer != null)
            {
                return Instancer.InstanceComponent();
            }
            return null;
        }

        public bool IsNeedLoad()
        {
            if (ArtDisPlay != null)
            {
                return ArtDisPlay.IsNeedLoad();
            }
            return false;
        }

        public bool IsNeedInstance()
        {
            if (ArtDisPlay != null)
            {
                return ArtDisPlay.IsNeedInstance();
            }
            return false;
        }
        /// <summary>
        /// 创建容器
        /// </summary>
        /// <returns></returns>
        public ArtContainer CreateContainer()
        {
            if (ArtDisPlay != null)
            {
                return ArtDisPlay.CreateContainer();
            }
            return null;
        }
        /// <summary>
        /// 创建一个美术展示容器
        /// </summary>
        public virtual ArtContainer CreateArt()
        {
            ///创建容器
            var container = CreateContainer();
            if (container == null)
            {
                UnityLog.LogError(info.ArtId + "__" + info.ArtType + "容器不存在！");
                return null;
            }
            AddToNode(container.GetInstace());



            ///资源的加载走异步处理
            if ((info.InstaceType == InstaceType.References || info.InstaceType == InstaceType.ResourceLoad ||
                    info.InstaceType == InstaceType.UnityBase))
            {
                UnityEngine.Object obj = null;
                if (IsNeedLoad())
                {
                    obj = LoadArt();
                }
                if (IsNeedInstance())
                {
                    obj = InstanceArt();
                }
                if (obj is GameObject)
                {
                    if (!(obj as GameObject).activeSelf)
                    {
                        (obj as GameObject).SetActive(true);
                    }
                }
                container.AddToContainer(obj, info);
                var artComponent = InstanceComponent();
                container.AddArtComponent(artComponent);
                if (artComponent != null)
                {
                    artComponent.SetContainer(container as ArtContainerHandler, obj, info);
                }
            }
            else
            {
                if (IsNeedLoad())
                {
                    if(container is ModelContainer)
                    {
                        bool isLoaded=false;
                        AssetLoaderContext asc = null;
                        TriLibModelLoad.Load(info.Url, (AssetLoaderContext ac) => {
                            isLoaded = true;
                            Debug.Log("模型加载完成");
                            ChangeLayerRecursively(ac.RootGameObject.transform);
                            container.AddToContainer(ac.RootGameObject, info);
                            var artComponent = InstanceComponent();
                            container.AddArtComponent(artComponent);
                            if (artComponent != null)
                            {
                                artComponent.SetContainer(container as ArtContainerHandler, ac.RootGameObject, info);
                            }
                        }, (AssetLoaderContext ac) => {
                            Debug.Log("载材质加完成");

                        }, (AssetLoaderContext ac, float f) => {
                            asc = ac;
                            container.UpdateProcess(f);
                            Debug.Log("开始加载 ParseModel_Coroutine" + f);
                        }, (IContextualizedError error) => {
                            isLoaded = true;
                        }, (container as ModelContainer).ModelRoot.gameObject);
                        Timer t = null;
                        t =  TimerMgr.Instance.CreateTimer(()=> {
                            if(!isLoaded&& container!=null&& (container as ModelContainer).ModelRoot!=null)
                            {
                                (container as ModelContainer).CalculateRendererBounds(true);
                                ChangeLayerRecursively((container as ModelContainer).ModelRoot);
                            }
                            else
                            {
                                TimerMgr.Instance.DestroyTimer(t);
                            }
                        },1,-1);
                    }
                    else
                    {

                        LoadArtAsyn("", container.UpdateProcess, (obj) =>
                        {
                            if (IsNeedInstance())
                            {
                                 obj = InstanceArt();
                            }
                            if (obj is GameObject)
                            {
                                if (!(obj as GameObject).activeSelf)
                                {
                                    (obj as GameObject).SetActive(true);
                                }
                            }
                            container.AddToContainer(obj, info);
                            var artComponent = InstanceComponent();
                            container.AddArtComponent(artComponent);
                            if (artComponent != null)
                            {
                                artComponent.SetContainer(container as ArtContainerHandler, obj, info);
                            }
                        });
                    }
                }
            }

            container.SetArtHandler(this);
            OnCreateArt?.Invoke(ArtDisPlay);
            return container;
        }    
        /// <summary>
            ///  更改层级
            /// </summary>
            /// <param name="parentTransform"></param>
        public void ChangeLayerRecursively(Transform parentTransform)
        {
            // 修改父物体的层级
            parentTransform.gameObject.layer = LayerMask.NameToLayer("Arrow");

            // 遍历所有子物体，并递归调用ChangeLayerRecursively方法
            for (int i = 0; i < parentTransform.childCount; i++)
            {
                Transform childTransform = parentTransform.GetChild(i);
                ChangeLayerRecursively(childTransform);
            }
        }
        /// <summary>
        /// 异步创建容器
        /// </summary>
        /// <param name="createAction"></param>
        public virtual void CreateArt(Action<ArtContainer> createAction)
        {

        }
        /// <summary>
        /// 是否已下载
        /// </summary>
        /// <returns></returns>
        public bool IsDownLoad()
        {
            if ((info.InstaceType == InstaceType.References || info.InstaceType == InstaceType.ResourceLoad ||
                    info.InstaceType == InstaceType.UnityBase))
            {
                Instancer.DownProcess = 1;
                return true;
            }
            return Instancer.IsDownLoad();
        }

        public void DownLoad(Action<float, float> downProcess, Action<string, byte[]> downComplete)
        {
            Instancer.DownLoad(downProcess, downComplete);
        }
    }
}