GHZMRSpace/Assets/Studio/XRLib/Codes/XRUI/UI/XRVideoPlayer.cs

using DG.Tweening;
using System;
using System.Collections;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
using UnityEngine.Video;
using XRTool.Util;

namespace XRTool.WorldUI
{
    /// <summary>
    /// 基本的3D图形
    /// 与UI Image进行结合转化，自动换算
    /// </summary>
    public class XRVideoPlayer : MonoBehaviour
    {
        private XRSlider xRSlider;
        private XRImage3D bG;
        private XRImage3D xRImage3D;
        private XRImage3D pause;
        private RenderTexture videoTexture;
        public RenderTexture VideoTexture { get => videoTexture; set => videoTexture = value; }
        private RectTransform rectTransform;
        private Vector2 videoSize;
        public bool isDown = false;
        private int hour, mint;
        private TextMesh timeText;
        private VideoPlayer videoPlayer;
        private Transform root;
        private MeshFilter body;
        private Renderer bodyRender;
        public bool isAutoScale = true;
        public float thickness = 100;
      //  public float scale = 0.5f;
        public VideoClip video;
        private XRButton xRButton;
        private BoxCollider box;


        void Start()
        {
            if (video)
            {
                SetSimple();
            }
            StartCoroutine(videoUpdate());
            TimeText.text = "0:00";
          //  XRImage3D.SetColor(Color.black);
            initVideo();
        }

        private IEnumerator InitVideoPlayer()
        {
            yield return VideoPlayer;
            while (!VideoPlayer.isPrepared)
            {
                yield return new WaitForFixedUpdate();
            }
            Vector2 size = Vector2.one;
            size.x = VideoPlayer.texture.width;
            size.y = VideoPlayer.texture.height;
        //    Box.size = new Vector3(size.x/RectTransform.localScale.x, size.y / RectTransform.localScale.y, 1);
            if (!VideoTexture)
            {
                VideoTexture = new RenderTexture((int)size.x, (int)size.y, 0);
            }
            else
            {
                VideoTexture.width = (int)size.x;
                VideoTexture.width = (int)size.y;
            }
            XRImage3D.SetColor(Color.white);
            VideoPlayer.targetTexture = VideoTexture;
            XRImage3D.SetSimple(VideoTexture);
        }

        public void SetSimple(VideoClip tex)
        {
            this.video = tex;
            if (this.gameObject!=null)
            {
               UnityUtil.ChangeMateVideo(VideoPlayer.gameObject, tex);
            }
        }
        public void SetColor(Color color) {
            if (BodyRender  && BodyRender.enabled)
            {
                try
                {
                    UnityUtil.ChangeMateColor(BodyRender, color);
                }
                catch (Exception ex)
                {
                    UnityLog.Instance.LogError(BodyRender.material + " have no mainTexture");
                }
            }
        }
        public void SetSimple(Texture tex)
        {
            if (BodyRender && tex && BodyRender.enabled)
            {
                try
                {
                    UnityUtil.ChangeMateTexture(BodyRender, tex);
                }
                catch (Exception ex)
                {
                    UnityLog.Instance.LogError(BodyRender.material + " have no mainTexture");
                }
            }
        }
        public void SetSimple()
        {
            if (video)
            {
                SetSimple(video);
            }
        }
        /// <summary>
        /// 3D物体
        /// </summary>
        public MeshFilter Body
        {
            get
            {
                if (!body)
                {
                    body = UnityUtil.GetBreadthChild<MeshFilter>(transform, "Body");
                }
                return body;
            }
        }
        public XRButton XRButton
        {
            get
            {
                if (!xRButton)
                {
                    xRButton = UnityUtil.GetBreadthChild<XRButton>(transform, "XRButton");
                }
                return xRButton;
            }

        }

        public BoxCollider Box
        {
            get
            {
                if (!box)
                {
                   box = this.GetComponent<BoxCollider>();
                }
                return box;
            }

        }

        public Transform Root
        {
            get
            {
                if (!root)
                {
                    root = UnityUtil.GetBreadthChild<Transform>(transform, "Root");
                }
                return root;
            }
            set => root = value;
        }
        public RectTransform RectTransform
        {
            get
            {
                if (!rectTransform)
                {
                    rectTransform = this.GetComponent<RectTransform>();
                }
                return rectTransform;
            }
            set => rectTransform = value;
        }

        public Vector2 VideoSize
        {
            get
            {
                if (videoSize== Vector2.zero)
                {
                    videoSize =new Vector2( videoPlayer.width, videoPlayer.height);
                }
                return videoSize;
            }
        }
        public XRImage3D XRImage3D
        {
            get
            {
                if (!xRImage3D)
                {
                    xRImage3D = UnityUtil.GetBreadthChild<XRImage3D>(transform, "XRImage3D");
                }
                return xRImage3D;
            }
        }
        public XRImage3D BG
        {
            get
            {
                if (!bG)
                {
                    bG = UnityUtil.GetBreadthChild<XRImage3D>(transform, "BG");
                }
                return bG;
            }
        }
        public XRImage3D Pause
        {
            get
            {
                if (!pause)
                {
                    pause = UnityUtil.GetBreadthChild<XRImage3D>(transform, "Pause");
                }
                return pause;
            }
        }
        
        public VideoPlayer VideoPlayer
        {
            get
            {
                if (!videoPlayer)
                {
                    videoPlayer = this.GetComponent<VideoPlayer>();
                }
                return videoPlayer;
            }
        }

        public TextMesh TimeText
        {
            get
            {
                if (!timeText)
                {
                    timeText = UnityUtil.GetBreadthChild<TextMesh>(transform, "TimeText");
                }
                return timeText;
            }
        }

        public Renderer BodyRender
        {
            get
            {
                if (!bodyRender)
                {
                    bodyRender = UnityUtil.GetBreadthChild<Renderer>(transform, "Body");
                }
                return bodyRender;
            }
        }


        /// <summary>
        /// 如果不是全等缩放，则设置厚度
        /// </summary>
        public void SetThickness()
        {
            SetThickness(thickness);
        }
        public void SetRenderMesh(Mesh mesh)
        {
            if (Body && mesh && Body.sharedMesh != mesh)
            {
                Body.sharedMesh = mesh;
                Body.transform.localPosition = Vector3.zero;
                Body.transform.localRotation = Quaternion.identity;
                Vector3 center = mesh.bounds.center;
                Vector3 pos = -center;
                pos.z = -(mesh.bounds.center.z + mesh.bounds.size.z) / 2;
                Body.transform.localPosition = pos;
            }
        }
        public void SetRenderMate(Material mate)
        {
            if (BodyRender && mate)
            {
                BodyRender.material = mate;
            }
        }
        public void AutoSetSize()
        {
            if (Root)
            {
                Vector3 size = RectTransform.rect.size;
                if (!isAutoScale)
                {
                    size.z = thickness;
                }
                else
                {
                    size.z = RectTransform.rect.size.x > RectTransform.rect.size.y ?
                        RectTransform.rect.size.y : RectTransform.rect.size.x;
                }
              //  Root.localScale = size * scale;
            }
        }

        public void SetThickness(float thickness)
        {
            this.thickness = thickness;
            if (!isAutoScale && Root)
            {
                Vector3 tmp = Root.localScale;
              //  tmp.z = thickness * scale;
              //  Root.localScale = tmp;
            }
        }
        /// <summary>
        /// 厚度变化动效
        /// </summary>
        /// <param name="pressDis">比例，相对于物体厚度的本身比例</param>
        /// <param name="pressTime">变化事件</param>
        public void DoThickness(float pressDis, float pressTime)
        {
            if (Root)
            {
                Root.DOKill();
                float target = thickness * pressDis;
                if (isAutoScale)
                {
                 //   target = (RectTransform.rect.size.x > RectTransform.rect.size.y ?
                 //       RectTransform.rect.size.y : RectTransform.rect.size.x) * scale;
                }
              //  Root.DOScaleZ(target, pressTime);
            }
        }

        void OnRectTransformDimensionsChange()
        {
            AutoSetSize();
        }




        public XRSlider XRSlider
        {
            get
            {
                if (!xRSlider)
                {
                    xRSlider = UnityUtil.GetBreadthChild<XRSlider>(transform, "XRSlider");
                }
                return xRSlider;
            }
        }
        

        IEnumerator videoUpdate()
        {
            while (true)
            {
                if (XRSlider && VideoPlayer && isDown == false)
                {
                    if (videoPlayer.isPlaying)
                    {
                        XRSlider.value = float.Parse(VideoPlayer.frame.ToString()) / float.Parse(VideoPlayer.frameCount.ToString());
                        TimeText.text = GetNowTime() + "/" + GetMaxTime();


                        XRImage3D.transform.localScale = new Vector3(XRImage3D.transform.localScale.x
                          , 1/(VideoSize.x/VideoSize.y), XRImage3D.transform.localScale.z);
                     //   Debug.Log(VideoSize.ToString());
                        XRSlider.gameObject.SetActive(true);
                    }
                    else
                    {
                        XRSlider.gameObject.SetActive(false);
                    }
                }

                if (!VideoPlayer.isPlaying&&!isShowControl)
                {
                    showControl();
                }
                    yield return new WaitForSeconds(0.035f);
            }
        }

        public string GetNowTime()
        {
            double f = VideoPlayer.time;
            hour = (int)f / 60;
            mint = (int)f % 60;
            return string.Format(" {0:D2}:{1:D2}", hour.ToString(), mint.ToString());
        }

        public string GetMaxTime()
        {
            float f = VideoPlayer.frameCount / VideoPlayer.frameRate;
            hour = (int)f / 60;
            mint = (int)f % 60;
            return string.Format(" {0:D2}:{1:D2}", hour.ToString(), mint.ToString());

        }

       public void sliderChanged(float per)
        {
            if (XRSlider && VideoPlayer)
            {
                float targetFrame = VideoPlayer.frameCount * per;
                VideoPlayer.frame = (long)targetFrame;
            }
        }

        public void initVideo()
        {
            StartCoroutine(InitVideoPlayer());
        }

        bool isShowControl = true;
        public void showControl()
        {
            if(!isShowControl)
            {
                GameEffect.setAlpha(Pause.gameObject, 1, 0.5f);
                GameEffect.setAlpha(XRSlider.gameObject, 1, 0.5f);
                GameEffect.setAlpha(BG.gameObject, 1, 0.5f);
                isShowControl = true;
            }
        }

        public void hideControl()
        {
            if (VideoPlayer.isPlaying&& isShowControl)
            {
                GameEffect.setAlpha(Pause.gameObject, 0, 0.5f, (GameObject obj) => {
                    obj.SetActive(false);
                });
                GameEffect.setAlpha(XRSlider.gameObject, 0, 0.5f, (GameObject obj) => {
                    obj.SetActive(false);
                });
                GameEffect.setAlpha(BG.gameObject, 0, 0.5f,(GameObject obj)=> {
                    obj.SetActive(false);
                });
                isShowControl = false;
            }
        }
    }
}