GHZMRNavigatorProXR/Assets/HotUpdate/TemplateModel.cs

using SC.XR.Unity.Module_InputSystem;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Reflection;
using TriLibCore;
using TriLibCore.Extensions;
using UnityEngine;

public class TemplateModel : BaseTemPlate
{
    private GameObject m_ModelObj = null;
    protected override void OnEnable()
    {
        base.OnEnable();
        if (GameManager.Instance.IsRuning && m_ModelObj == null)
        {
            Debug.Log("ExtractZipFile===>1");
            if (IsAB())
                LoadABModel();
            else
                TriLibModel();
        }
        else
        {
            if (m_ModelObj && m_ModelObj.GetComponent<Animation>())
            {
                Debug.Log("Animation===>1"+ m_ModelObj.name);

                Animation _animation = m_ModelObj.GetComponent<Animation>();
                List<AnimationClip> _animations = _animation.GetAllAnimationClips();
                m_ModelObj.GetComponent<Animation>().Play(_animations[0].name, PlayMode.StopAll);
            }
        }
        if(this.gameObject.GetComponent<AudioSource>())
        this.gameObject.GetComponent<AudioSource>().Play();
    }

    private IEnumerator LoadModel()
    {
        yield return new WaitForSeconds(0.01f);
        if (GameManager.Instance.IsRuning && m_ModelObj == null)
        {
            //Debug.Log(Data.name);
            Debug.Log("DGJ ==>>   "+Data.localLoadPath);
            var ab = AssetBundle.LoadFromFileAsync(Data.localLoadPath);
            yield return ab;
            if (ab == null)
            {
                Debug.Log("Failed to load AssetBundle!");

            }
            else
            {
                var allab = ab.assetBundle.LoadAllAssetsAsync<GameObject>();
                yield return allab;
                var prefab = ab.assetBundle.LoadAssetAsync<GameObject>((allab.allAssets[0] as GameObject).name);

                yield return prefab;
                switch (prefab.asset.name)
                {
                    case "GHZ_OOBE_230721":

                        var objload = Resources.LoadAsync<GameObject>("GongYe");
                        yield return objload;
                        GameObject obj = null;
                        if (objload.asset is GameObject)
                        {
                            obj = objload.asset as GameObject;

                        }
                        if (obj == null)
                        {
                            Debug.LogError(" GHZ_OOBE_230721  物体加载失败，请查看是否导入相关Packages ");
                            obj = new GameObject();
                          
                        }
                        m_ModelObj = GameObject.Instantiate(obj,transform);
                        m_ModelObj.name = "GongYe";

                        if (GameObject.Find("AudioManager") ==null)
                        {
                            GameObject audio = Resources.Load<GameObject>("AudioManager");
                            if(audio ==null)
                            {
                                Debug.LogError("  GHZ_OOBE_230721 Packages内AudioManager组件丢失");
                                audio = new GameObject();
                            }
                            GameObject Audio = GameObject.Instantiate(audio, transform);
                            Audio.name = "AudioManager";
                        }
                        break;

                    case "GHZ_XXXXXX_230721":

                        break;

                    default:
                        m_ModelObj = Instantiate(prefab.asset as GameObject, transform);
                        break;
                }

              

                //if (ab.LoadAllAssets<GameObject>()[0].name == "MRVideo")
                //m_ModelObj.AddComponent<MovieScreen>();

                gameObject.AddComponent<ManipulationHandler>();
                gameObject.AddComponent<BoundingBox>();
                gameObject.AddComponent<Patch_ModelController>();
                yield return new WaitForSeconds(0.3f);
                ab.assetBundle.Unload(false);
                HideCollider();
            }
          



            //var obj = DownloadManager.Instance.GetAbObj(Util.MD5Encrypt(Data.downloadPath));
            //if (obj != null)
            //{
            //    m_ModelObj = Instantiate(obj, transform);
            //    m_ModelObj.transform.localPosition = Vector3.zero;
            //    m_ModelObj.gameObject.SetActive(true);
            //}
        }
    }
    public void LoadModel(AssetBundle ab)
    {
      GameManager.Instance.StartCoroutine(LoadABModel(ab));
        //LoadABModel(ab);
    }
    private IEnumerator LoadABModel(AssetBundle ab)
    {
        if (ab == null)
        {
            Debug.Log("Failed to load AssetBundle!");

        }
        else
        {
            var allab = ab.LoadAllAssetsAsync<GameObject>();
            yield return allab;
            var prefab = ab.LoadAssetAsync<GameObject>((allab.allAssets[0] as GameObject).name);

            switch (prefab.asset.name)
            {
                case "GHZ_OOBE_230721":

                    var objload = Resources.LoadAsync<GameObject>("GongYe");
                    yield return objload;
                    GameObject obj = null;
                    if (objload.asset is GameObject)
                    {
                        obj = objload.asset as GameObject;

                    }
                    m_ModelObj = GameObject.Instantiate(obj, transform);
                    m_ModelObj.name = "GongYe";

                    if (GameObject.Find("AudioManager") == null)
                    {
                        GameObject audio = Resources.Load<GameObject>("AudioManager");
                        if (audio == null)
                        {
                            Debug.LogError("  GHZ_OOBE_230721 Packages内AudioManager组件丢失");
                            audio = new GameObject();
                        }
                        GameObject Audio = GameObject.Instantiate(audio, null);
                        Audio.name = "AudioManager";
                    }
                    break;

                case "GHZ_XXXXXX_230721":

                    break;

                default:
                    m_ModelObj = Instantiate(prefab.asset as GameObject, transform);
                    break;
            }



            //if (ab.LoadAllAssets<GameObject>()[0].name == "MRVideo")
            //m_ModelObj.AddComponent<MovieScreen>();

            gameObject.AddComponent<ManipulationHandler>();
            gameObject.AddComponent<BoundingBox>();
           // yield return new WaitForSeconds(0.3f);
            ab.Unload(false);
            HideCollider();
            ModelItem.isLoad = false;
        }
    }

    protected override void OnAwake()
    {
        base.OnAwake();
    }

    public override void SetData(MaterialObjValue value, int updateTime)
    {
       
        base.SetData(value, updateTime);
        //if (gameObject.GetComponent<Collider>() != null)
        //{
        //    Destroy(gameObject.GetComponent<Collider>());
        //}
        //下载列表中加入数据
        if (!GameManager.Instance.IsRuning|| Data == null)
        {
            //   DownloadManager.Instance.AddDownloadData(Data);


            DownLoadMaterial data = new DownLoadMaterial();
            this.Data = data;
            data.downLoadPath = value.DownloadPath;
            data.localLoadPath = Application.persistentDataPath + "/Material/" + Path.GetFileName(value.DownloadPath);
            data.updataTime = GameManager.Instance.m_SceneValue.updateTime;
            data.type = "3";
            MsgHandler.AddListener(value.DownloadPath, HandleMsg);
            DownloadResManager.Instance.DownLoad(data);
            Debug.Log(" SetData " + updateTime);
        }
        else
        {

            if (IsAB())
                LoadABModel();
            else
                TriLibModel();
            //AssetBundle ab = AssetBundle.LoadFromFile(Data.localLoadPath);
            //if (ab == null)
            //{
            //    Debug.Log("Failed to load AssetBundle!");
            //    return;
            //}
            //var prefab = ab.LoadAsset<GameObject>(ab.LoadAllAssets<GameObject>()[0].name);
            //m_ModelObj = Instantiate(prefab, transform);
            //ab.Unload(false);

            //gameObject.AddComponent<ManipulationHandler>();
            //gameObject.AddComponent<BoundingBox>();
            //var obj = DownloadManager.Instance.GetAbObj(Util.MD5Encrypt(Data.downloadPath));
            //if (obj != null)
            //{
            //    m_ModelObj = Instantiate(obj, transform);
            //    m_ModelObj.transform.localPosition = Vector3.zero;
            //    m_ModelObj.gameObject.SetActive(true);
            //}

        }
       
    }

    private void HandleMsg(Msg msg)
    {
        Debug.Log("DGJ   TemplateModel ");

        if(msg.Value!=null)
        {
            if (IsAB())
                LoadABModel();
            else
                TriLibModel();
        }
        else
        {
            InstantiateCommand Command = new InstantiateCommand(
               InstantiateSystem.Instance.BlueObject.WarningPopUp,
               InstantiateSystem.Instance.BlueObject.NetErrorText);
            CommandSystem.Instance.Send(Command);
            Debug.LogError("  模型下载失败 ");
        }


    }

    private bool IsAB()
    {
        bool finish = false;

        string fileName = Path.GetFileName(Data.localLoadPath);
        Debug.Log("HJJ   fileName===>"+ fileName);
        if(fileName.Contains(".ghb") ||!fileName.Contains("."))
        {
            finish = true;
        }

        return finish;
    }

    private void LoadABModel()
    {
        AssetBundle ab = AssetBundle.LoadFromFile(Data.localLoadPath);
        if (ab == null)
        {
            Debug.Log("Failed to load AssetBundle!");
            return;
        }
        var prefab = ab.LoadAsset<GameObject>(ab.LoadAllAssets<GameObject>()[0].name);
        m_ModelObj = Instantiate(prefab, transform);
        ab.Unload(false);

        ManipulationHandler manipulation = gameObject.AddComponent<ManipulationHandler>();
        manipulation.enabled = false;
        BoundingBox boundingBox = gameObject.AddComponent<BoundingBox>();
        boundingBox.enabled = false;
    }
    /// <summary>
    /// 解压
    /// </summary>
    /// <param name="zipFilePath">压缩文件路径</param>
    /// <param name="extractPath">解压路径</param>
    public bool ExtractZipFile(string zipFilePath)
    {
        bool isAB=false;
        if(!zipFilePath.Contains(".zip"))
        {
            return false;
        }
        Debug.Log("ExtractZipFile===>1");
        using (ZipArchive archive = ZipFile.OpenRead(zipFilePath))
        {
                byte[] ghbbytes = null;
                Debug.Log("ExtractZipFile===>2");
                foreach (ZipArchiveEntry entry in archive.Entries)
                {
                    Debug.Log("ExtractZipFile==FullName=>2" + entry.FullName);
                    if (entry.FullName.Contains(".ghb") || !entry.FullName.Contains("."))
                    {
                        isAB = true;
                        if (entry.Name != "")
                        {
                            entry.ExtractToFile(Application.persistentDataPath+"/"+ entry.FullName,true);
                            FileInfo finfo = new FileInfo(Application.persistentDataPath + "/" + entry.FullName);
                            byte[] bytes= readbytes(finfo.OpenRead());
                            if (!entry.FullName.Contains(".bytes"))
                            {
                                ghbbytes = bytes;
                            }
                           
                        }

                    }
                    else if(entry.FullName.Contains(".mp3"))
                    {

                        if (entry.Name != ""&&File.Exists(Application.persistentDataPath + "/" + entry.FullName))
                        {
                            entry.ExtractToFile(Application.persistentDataPath + "/" + entry.FullName, true);
                            FileInfo finfo = new FileInfo(Application.persistentDataPath + "/" + entry.FullName);
                            byte[] bytes = readbytes(finfo.OpenRead());
                            float[] fs = bytesToFloat(bytes);
                            AudioClip clip = AudioClip.Create(entry.FullName, fs.Length, 1, 16000, false);
                            clip.SetData(fs, 0);
                            if(!this.gameObject.GetComponent<AudioSource>())
                            {
                                this.gameObject.AddComponent<AudioSource>();
                            }
                            this.gameObject.GetComponent<AudioSource>().clip = clip;
                            this.gameObject.GetComponent<AudioSource>().Play();
                        }
                        return true;
                }
                }

                if(isAB)
                {
                    Debug.Log("ExtractZipFile===>3");
                    if (ghbbytes!=null)
                    {
                        Debug.Log("ExtractZipFile===>5");
                        AssetBundle ab = AssetBundle.LoadFromMemory(ghbbytes);
                        var prefab = ab.LoadAsset<GameObject>(ab.LoadAllAssets<GameObject>()[0].name);
                        m_ModelObj = Instantiate(prefab, transform);
                        ab.Unload(false);

                        ManipulationHandler manipulation = gameObject.AddComponent<ManipulationHandler>();
                        manipulation.enabled = false;
                        BoundingBox boundingBox = gameObject.AddComponent<BoundingBox>();
                        boundingBox.enabled = false;
                    }
                }

   

            return isAB;
        }
    }

    public static float[] bytesToFloat(byte[] byteArray)//byte[]数组转化为AudioClip可读取的float[]类型
    {
        float[] sounddata = new float[byteArray.Length / 2];
        for (int i = 0; i < sounddata.Length; i++)
        {
            sounddata[i] = bytesToFloat(byteArray[i * 2], byteArray[i * 2 + 1]);
        }
        return sounddata;
    }

    static float bytesToFloat(byte firstByte, byte secondByte)
    {
        // convert two bytes to one short (little endian)
        //小端和大端顺序要调整
        short s;
        if (BitConverter.IsLittleEndian)
            s = (short)((secondByte << 8) | firstByte);
        else
            s = (short)((firstByte << 8) | secondByte);
        // convert to range from -1 to (just below) 1
        return s / 32768.0F;
    }
    public byte[] readbytes(Stream stream)
    {

        using (Stream fs = stream)
        {
            byte[] bytes = new byte[fs.Length];
            fs.Read(bytes, 0, bytes.Length);
            fs.Close();
            return bytes;
        }
    }
    public void TriLibModel()
    {
        if(m_ModelObj)
        {
            return;
        }

        Debug.Log("模型加载完成TriLibModel" + Data.localLoadPath);

        if (false)//ExtractZipFile(Data.localLoadPath)
        {

        }
        else
        {

            Debug.Log("模型加载完成TriLibModel" + Data.localLoadPath);

            try
            {

                TriLibModelLoad.Load(Data.localLoadPath, (AssetLoaderContext ac) => {
                    Debug.Log("模型加载完成");
                }, (AssetLoaderContext ac) => {
                    Debug.Log("载材质加完成");
                    Bounds bounds = GetAllBounds.GetRendererBounds(ac.RootGameObject);
                    GameObject obj = new GameObject("Test");
                    obj.transform.position = bounds.center;
                    obj.transform.SetParent(ac.RootGameObject.transform);
                    float bizhi = 0.4f / bounds.size.x;
                    ac.RootGameObject.transform.localScale = Vector3.one * bizhi;
                    ac.RootGameObject.transform.SetParent(this.transform.parent);
                    Vector3 v3local = (Vector3.zero - obj.transform.position) ;
                    ac.RootGameObject.transform.SetParent(this.transform);
                    ac.RootGameObject.transform.localPosition = v3local;
                    ac.RootGameObject.transform.localScale = ac.RootGameObject.transform.localScale * this.transform.localScale.x; 
                    ac.RootGameObject.transform.localEulerAngles = Vector3.zero;
                    ac.RootGameObject.SetActive(true);

                    //  ac.RootGameObject.transform.position = Camera.main.transform.forward;
                    m_ModelObj = Instantiate(ac.RootGameObject, transform);
                    ManipulationHandler manipulation = gameObject.AddComponent<ManipulationHandler>();
                    manipulation.enabled = false;
                    BoundingBox boundingBox = gameObject.AddComponent<BoundingBox>();
                    boundingBox.enabled = false;
                    ac.RootGameObject.SetActive(false);

                    if (m_ModelObj && m_ModelObj.GetComponent<Animation>())
                    {
                        Debug.Log("Animation===>1" + m_ModelObj.name);

                        Animation _animation = m_ModelObj.GetComponent<Animation>();
                        List<AnimationClip> _animations = _animation.GetAllAnimationClips();
                        m_ModelObj.GetComponent<Animation>().Play(_animations[0].name, PlayMode.StopAll);
                    }
                    if (this.gameObject.GetComponent<BoxCollider>())
                    {
                        this.gameObject.GetComponent<BoxCollider>().size = Vector3.one * 0.4f;
                    }
                }, (AssetLoaderContext ac, float f) => {

                    Debug.Log("加载中==》" + f);
                }, (IContextualizedError error) => {

                    Debug.Log("加载失败" + error);
                });
            }
            catch
            {
                Debug.Log("加载失败" + Data.localLoadPath);
            }
        }
    }

    public override void HideCollider()
    {
        base.HideCollider();
    }
}