【Unity】WebGLで動画再生を独自実装する

var SimpleWebGLVideoPlayer = {
    $videos: {},
    $videoIdCounter: 0,

    SimpleWebGLVideoPlayer_Create: function (url) {
        const video = document.createElement('video');
        video.style.display = 'none';
        video.src = UTF8ToString(url);
        video.muted = true;
        video.setAttribute("muted", "");
        video.setAttribute("playsinline", "");
        video.crossOrigin = "anonymous";

        videos[++videoIdCounter] = video;

        return videoIdCounter;
    },

    SimpleWebGLVideoPlayer_UpdateToTexture: function (id, tex) {
        const video = videos[id];

        if (video.seeking) return false;
        if (video.currentTime === video.lastUpdateTextureTime) return false;

        video.lastUpdateTextureTime = video.currentTime;
        GLctx.pixelStorei(GLctx.UNPACK_FLIP_Y_WEBGL, true);
        GLctx.bindTexture(GLctx.TEXTURE_2D, GL.textures[tex]);

        GLctx.texImage2D(GLctx.TEXTURE_2D, 0, GLctx.RGBA, GLctx.RGBA, GLctx.UNSIGNED_BYTE, video);
        GLctx.pixelStorei(GLctx.UNPACK_FLIP_Y_WEBGL, false);

        return true;
    },

    SimpleWebGLVideoPlayer_Destroy: function (id) {
        const video = videos[id];
        video.src = '';
        delete videos[id];
    },

    SimpleWebGLVideoPlayer_Play: function (id) {
        const video = videos[id];
        video.play();
    },

    SimpleWebGLVideoPlayer_GetWidth: function (id) {
        const video = videos[id];
        return video.videoWidth;
    },

    SimpleWebGLVideoPlayer_GetHeight: function (id) {
        const video = videos[id];
        return video.videoHeight;
    },
};

autoAddDeps(SimpleWebGLVideoPlayer, '$videos');
autoAddDeps(SimpleWebGLVideoPlayer, '$videoIdCounter');
mergeInto(LibraryManager.library, SimpleWebGLVideoPlayer);

using System;
using System.Runtime.InteropServices;
using UnityEngine;

public class SimpleWebGLVideoPlayer : MonoBehaviour
{
    // 動画のURL
    [SerializeField] private string _url;

    // レンダリング先のRenderTexture
    [SerializeField] private RenderTexture _targetRenderTexture;

    // 色空間をsRGBからLinearに変換するシェーダ
    [SerializeField] private Shader _sRGBToLinearShader;

    // 内部管理用のインスタンスID
    private int _videoInstanceID;

    // 動画のテクスチャ
    private Texture2D _texture;

    // sRGBからLinearに変換するためのマテリアル
    private Material _sRGBToLinearMaterial;

    // 現在の動画解像度
    private Vector2Int _videoResolution;

    #region ネイティブ関数のインポート

    [DllImport("__Internal")]
    private static extern int SimpleWebGLVideoPlayer_Create(string url);

    [DllImport("__Internal")]
    private static extern void SimpleWebGLVideoPlayer_UpdateToTexture(int instanceID, IntPtr texture);

    [DllImport("__Internal")]
    private static extern void SimpleWebGLVideoPlayer_Destroy(int instanceID);

    [DllImport("__Internal")]
    private static extern void SimpleWebGLVideoPlayer_Play(int instanceID);

    [DllImport("__Internal")]
    private static extern int SimpleWebGLVideoPlayer_GetWidth(int instanceID);

    [DllImport("__Internal")]
    private static extern int SimpleWebGLVideoPlayer_GetHeight(int instanceID);

    #endregion

    /// <summary>
    /// 初期化
    /// </summary>
    private void Start()
    {
        // video要素のインスタンス生成
        _videoInstanceID = SimpleWebGLVideoPlayer_Create(_url);

        // 色空間がLinearの場合、動画のテクスチャをsRGBからLinearに変換する必要がある
        if (_sRGBToLinearShader != null &&
            QualitySettings.activeColorSpace == ColorSpace.Linear)
        {
            // sRGBからLinearに変換するためのマテリアルを作成
            _sRGBToLinearMaterial = new Material(_sRGBToLinearShader);
        }
        
        // 動画を再生
        SimpleWebGLVideoPlayer_Play(_videoInstanceID);
    }

    /// <summary>
    /// 後処理
    /// </summary>
    private void OnDestroy()
    {
        // video要素のインスタンスを破棄
        if (_videoInstanceID > 0)
        {
            SimpleWebGLVideoPlayer_Destroy(_videoInstanceID);
            _videoInstanceID = 0;
        }

        if (_texture != null)
        {
            // テクスチャを破棄
            Destroy(_texture);
            _texture = null;
        }

        if (_sRGBToLinearMaterial != null)
        {
            // マテリアルを破棄
            Destroy(_sRGBToLinearMaterial);
            _sRGBToLinearMaterial = null;
        }
    }

    /// <summary>
    /// フレーム更新
    /// </summary>
    public void Update()
    {
        // 動画の解像度を取得
        var resolution = new Vector2Int(
            SimpleWebGLVideoPlayer_GetWidth(_videoInstanceID),
            SimpleWebGLVideoPlayer_GetHeight(_videoInstanceID)
        );

        if (resolution.x <= 0 || resolution.y <= 0)
            return;

        // 動画の解像度が変更されたら、動画のテクスチャを再作成
        if (_videoResolution != resolution)
        {
            _videoResolution = resolution;

            if (_texture != null)
            {
                Destroy(_texture);
                _texture = null;
            }

            _texture = new Texture2D(_videoResolution.x, _videoResolution.y, TextureFormat.RGBA32, false);
        }

        SimpleWebGLVideoPlayer_UpdateToTexture(_videoInstanceID, _texture.GetNativeTexturePtr());

        if (_sRGBToLinearMaterial != null)
            Graphics.Blit(_texture, _targetRenderTexture, _sRGBToLinearMaterial);
        else
            Graphics.Blit(_texture, _targetRenderTexture);
    }
}

Shader "Hidden/sRGBToLinear"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Cull Off ZWrite Off ZTest Always

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                return o;
            }

            sampler2D _MainTex;

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 sRGB = tex2D(_MainTex, i.uv);
                const float3 c = sRGB.rgb;
                return fixed4(c * (c * (c * 0.305306011 + 0.682171111) + 0.012522878), sRGB.a);
            }
            ENDCG
        }
    }
}

var WebGLVideoControl = {
    $webGLVideoControlInstances: {},
    $webGLVideoControlIdCounter: 0,

    WebGLVideoControl_Create: function (url) {
        const video = document.createElement('video');
        video.style.display = 'none';
        video.src = UTF8ToString(url);
        video.muted = true;
        video.setAttribute("muted", "");
        video.setAttribute("playsinline", "");
        video.crossOrigin = "anonymous";

        webGLVideoControlInstances[++webGLVideoControlIdCounter] = video;

        return webGLVideoControlIdCounter;
    },

    WebGLVideoControl_UpdateToTexture: function (id, tex) {
        const video = webGLVideoControlInstances[id];

        if (video.seeking) return false;
        if (video.currentTime === video.lastUpdateTextureTime) return false;

        video.lastUpdateTextureTime = video.currentTime;
        GLctx.pixelStorei(GLctx.UNPACK_FLIP_Y_WEBGL, true);
        GLctx.bindTexture(GLctx.TEXTURE_2D, GL.textures[tex]);

        GLctx.texImage2D(GLctx.TEXTURE_2D, 0, GLctx.RGBA, GLctx.RGBA, GLctx.UNSIGNED_BYTE, video);
        GLctx.pixelStorei(GLctx.UNPACK_FLIP_Y_WEBGL, false);

        return true;
    },

    WebGLVideoControl_Destroy: function (id) {
        const video = webGLVideoControlInstances[id];
        video.src = '';
        delete webGLVideoControlInstances[id];
    },

    WebGLVideoControl_Play: function (id, muted) {
        const video = webGLVideoControlInstances[id];
        video.muted = muted;
        video.play();
    },

    WebGLVideoControl_Stop: function (id) {
        const video = webGLVideoControlInstances[id];
        video.pause();
        video.currentTime = 0;
    },

    WebGLVideoControl_Pause: function (id) {
        const video = webGLVideoControlInstances[id];
        video.pause();
    },

    WebGLVideoControl_StepForward: function (id) {
        const video = webGLVideoControlInstances[id];
        video.pause();
        video.currentTime += 1 / 24;
    },

    WebGLVideoControl_GetURL: function (id) {
        const video = webGLVideoControlInstances[id];

        const result = video.src;
        var bufferSize = lengthBytesUTF8(result) + 1;
        var buffer = _malloc(bufferSize);
        stringToUTF8(result, buffer, bufferSize);
        return buffer;
    },

    WebGLVideoControl_SetURL: function (id, url) {
        const video = webGLVideoControlInstances[id];
        video.src = UTF8ToString(url);
    },

    WebGLVideoControl_GetTime: function (id) {
        const video = webGLVideoControlInstances[id];
        return video.currentTime;
    },

    WebGLVideoControl_SetTime: function (id, time) {
        const video = webGLVideoControlInstances[id];

        if (video.readyState >= HTMLMediaElement.HAVE_METADATA)
            video.currentTime = time;
    },

    WebGLVideoControl_GetDuration: function (id) {
        const video = webGLVideoControlInstances[id];
        return video.duration;
    },

    WebGLVideoControl_IsMuted: function (id) {
        const video = webGLVideoControlInstances[id];
        return video.muted;
    },

    WebGLVideoControl_SetMuted: function (id, mute) {
        const video = webGLVideoControlInstances[id];
        video.muted = mute;
    },

    WebGLVideoControl_GetWidth: function (id) {
        const video = webGLVideoControlInstances[id];
        return video.videoWidth;
    },

    WebGLVideoControl_GetHeight: function (id) {
        const video = webGLVideoControlInstances[id];
        return video.videoHeight;
    },
};

autoAddDeps(WebGLVideoControl, '$webGLVideoControlInstances');
autoAddDeps(WebGLVideoControl, '$webGLVideoControlIdCounter');
mergeInto(LibraryManager.library, WebGLVideoControl);

using System;

public interface IVideoControl : IDisposable
{
    void Play();
    void Stop();
    void Pause();
    void StepForward();
    
    string URL { get; set; }
    double Time { get; set; }
    double Duration { get; }
    bool IsMuted { get; set; }
    
    void Update();
}

#if UNITY_EDITOR || !UNITY_WEBGL
using UnityEngine;
using UnityEngine.Video;

public class VideoPlayerControl : IVideoControl
{
    // 動画再生用のVideoPlayer
    private VideoPlayer _videoPlayer;

    /// <summary>
    /// コンストラクタ
    /// </summary>
    /// <param name="videoPlayerObject">VideoPlayerを追加するGameObject</param>
    /// <param name="url">動画のURL</param>
    /// <param name="targetRenderTexture">動画のレンダリング対象のRenderTexture </param>
    public VideoPlayerControl(GameObject videoPlayerObject, string url, RenderTexture targetRenderTexture)
    {
        // VideoPlayerコンポーネントを作成して初期化
        _videoPlayer = videoPlayerObject.AddComponent<VideoPlayer>();
        _videoPlayer.playOnAwake = false;
        _videoPlayer.url = url;
        _videoPlayer.source = VideoSource.Url;
        _videoPlayer.renderMode = VideoRenderMode.RenderTexture;
        _videoPlayer.targetTexture = targetRenderTexture;
    }

    /// <summary>
    /// 後処理
    /// </summary>
    public void Dispose()
    {
        if (_videoPlayer == null) return;

        // VideoPlayerコンポーネントを削除
        Object.Destroy(_videoPlayer);
        _videoPlayer = null;
    }

    /// <summary>
    /// 動画を再生する
    /// </summary>
    public void Play()
    {
        _videoPlayer.Play();
    }

    /// <summary>
    /// 動画再生を停止する
    /// </summary>
    public void Stop()
    {
        _videoPlayer.Stop();
    }

    /// <summary>
    /// 動画を一時停止する
    /// </summary>
    public void Pause()
    {
        _videoPlayer.Pause();
    }

    /// <summary>
    /// コマ送りする
    /// </summary>
    public void StepForward()
    {
        if (!_videoPlayer.isPaused)
            _videoPlayer.Pause();

        _videoPlayer.StepForward();
    }

    /// <summary>
    /// 動画のURL
    /// </summary>
    public string URL
    {
        get => _videoPlayer.url;
        set => _videoPlayer.url = value;
    }

    /// <summary>
    /// 現在時刻[s]
    /// </summary>
    public double Time
    {
        get => _videoPlayer.time;
        set => _videoPlayer.time = value;
    }

    /// <summary>
    /// 動画の長さ[s]
    /// </summary>
    public double Duration => _videoPlayer.length;

    /// <summary>
    /// ミュート状態
    /// </summary>
    public bool IsMuted
    {
        get
        {
            // どれか一つでもミュートされていないトラックがあれば、ミュートされていないと判定
            var isMuted = true;
            for (ushort i = 0; i < _videoPlayer.audioTrackCount; i++)
            {
                if (_videoPlayer.GetDirectAudioMute(i)) continue;

                isMuted = false;
                break;
            }

            return isMuted;
        }
        set
        {
            // 全てのオーディオトラックのミュート状態を設定
            for (ushort i = 0; i < _videoPlayer.audioTrackCount; i++)
            {
                _videoPlayer.SetDirectAudioMute(i, value);
            }
        }
    }

    public void Update()
    {
        // 何もしない
    }
}
#endif

using System;
using System.Runtime.InteropServices;
using UnityEngine;
using Object = UnityEngine.Object;

public class WebGLVideoControl : IVideoControl
{
    [DllImport("__Internal")]
    private static extern int WebGLVideoControl_Create(string url);

    [DllImport("__Internal")]
    private static extern void WebGLVideoControl_UpdateToTexture(int instanceID, IntPtr texture);

    [DllImport("__Internal")]
    private static extern void WebGLVideoControl_Destroy(int instanceID);

    [DllImport("__Internal")]
    private static extern void WebGLVideoControl_Play(int instanceID, bool muted);

    [DllImport("__Internal")]
    private static extern void WebGLVideoControl_Stop(int instanceID);

    [DllImport("__Internal")]
    private static extern void WebGLVideoControl_Pause(int instanceID);

    [DllImport("__Internal")]
    private static extern void WebGLVideoControl_StepForward(int instanceID);

    [DllImport("__Internal")]
    private static extern string WebGLVideoControl_GetURL(int instanceID);

    [DllImport("__Internal")]
    private static extern void WebGLVideoControl_SetURL(int instanceID, string url);

    [DllImport("__Internal")]
    private static extern double WebGLVideoControl_GetTime(int instanceID);

    [DllImport("__Internal")]
    private static extern void WebGLVideoControl_SetTime(int instanceID, double time);

    [DllImport("__Internal")]
    private static extern double WebGLVideoControl_GetDuration(int instanceID);

    [DllImport("__Internal")]
    private static extern bool WebGLVideoControl_IsMuted(int instanceID);

    [DllImport("__Internal")]
    private static extern void WebGLVideoControl_SetMuted(int instanceID, bool muted);

    [DllImport("__Internal")]
    private static extern int WebGLVideoControl_GetWidth(int instanceID);

    [DllImport("__Internal")]
    private static extern int WebGLVideoControl_GetHeight(int instanceID);

    // レンダリング先のRenderTexture
    private readonly RenderTexture _targetRenderTexture;
    
    // 内部管理用のインスタンスID
    private int _videoInstanceID;
    
    // 動画のテクスチャ
    private Texture2D _texture;
    
    // sRGBからLinearに変換するためのマテリアル
    private Material _sRGBToLinearMaterial;
    
    // ミュート状態
    private bool _isMuted;
    
    // 現在の動画解像度
    private Vector2Int _videoResolution;

    /// <summary>
    /// コンストラクタ
    /// </summary>
    /// <param name="url">動画のURL</param>
    /// <param name="targetRenderTexture">レンダリング先のRenderTexture</param>
    /// <param name="sRGBToLinearShader">sRGBからLinearに変換するためのシェーダー</param>
    public WebGLVideoControl(string url, RenderTexture targetRenderTexture, Shader sRGBToLinearShader)
    {
        // 引数を保持
        _targetRenderTexture = targetRenderTexture;
        _videoInstanceID = WebGLVideoControl_Create(url);

        // 色空間がLinearの場合、動画のテクスチャをsRGBからLinearに変換する必要がある
        if (sRGBToLinearShader != null &&
            QualitySettings.activeColorSpace == ColorSpace.Linear)
        {
            // sRGBからLinearに変換するためのマテリアルを作成
            _sRGBToLinearMaterial = new Material(sRGBToLinearShader);
        }
    }

    /// <summary>
    /// 後処理
    /// </summary>
    public void Dispose()
    {
        // video要素のインスタンスを破棄
        WebGLVideoControl_Destroy(_videoInstanceID);
        _videoInstanceID = 0;

        if (_texture != null)
        {
            // テクスチャを破棄
            Object.Destroy(_texture);
            _texture = null;
        }

        if (_sRGBToLinearMaterial != null)
        {
            // マテリアルを破棄
            Object.Destroy(_sRGBToLinearMaterial);
            _sRGBToLinearMaterial = null;
        }
    }

    /// <summary>
    /// 動画を再生する
    /// </summary>
    public void Play()
    {
        WebGLVideoControl_Play(_videoInstanceID, _isMuted);
    }

    /// <summary>
    /// 動画再生を停止する
    /// </summary>
    public void Stop()
    {
        WebGLVideoControl_Stop(_videoInstanceID);
    }

    /// <summary>
    /// 動画再生を一時停止する
    /// </summary>
    public void Pause()
    {
        WebGLVideoControl_Pause(_videoInstanceID);
    }

    /// <summary>
    /// コマ送りする
    /// </summary>
    public void StepForward()
    {
        WebGLVideoControl_StepForward(_videoInstanceID);
    }

    /// <summary>
    /// 動画のURL
    /// </summary>
    public string URL
    {
        get => WebGLVideoControl_GetURL(_videoInstanceID);
        set => WebGLVideoControl_SetURL(_videoInstanceID, value);
    }

    /// <summary>
    /// 現在時刻[s]
    /// </summary>
    public double Time
    {
        get => WebGLVideoControl_GetTime(_videoInstanceID);
        set => WebGLVideoControl_SetTime(_videoInstanceID, value);
    }

    /// <summary>
    /// 動画の長さ[s]
    /// </summary>
    public double Duration => WebGLVideoControl_GetDuration(_videoInstanceID);

    /// <summary>
    /// ミュート状態
    /// </summary>
    public bool IsMuted
    {
        get
        {
            _isMuted = WebGLVideoControl_IsMuted(_videoInstanceID);
            return _isMuted;
        }
        set
        {
            _isMuted = value;
            WebGLVideoControl_SetMuted(_videoInstanceID, value);
        }
    }

    /// <summary>
    /// フレーム更新
    /// </summary>
    public void Update()
    {
        // 動画の解像度を取得
        var resolution = new Vector2Int(
            WebGLVideoControl_GetWidth(_videoInstanceID),
            WebGLVideoControl_GetHeight(_videoInstanceID)
        );
        
        if (resolution.x <= 0 || resolution.y <= 0)
            return;
        
        // 動画の解像度が変更されたら、動画のテクスチャを再作成
        if (_videoResolution != resolution)
        {
            _videoResolution = resolution;
            
            if (_texture != null)
            {
                Object.Destroy(_texture);
                _texture = null;
            }

            _texture = new Texture2D(_videoResolution.x, _videoResolution.y, TextureFormat.RGBA32, false);
        }

        WebGLVideoControl_UpdateToTexture(_videoInstanceID, _texture.GetNativeTexturePtr());

        if (_sRGBToLinearMaterial != null)
            Graphics.Blit(_texture, _targetRenderTexture, _sRGBToLinearMaterial);
        else
            Graphics.Blit(_texture, _targetRenderTexture);
    }
}

using UnityEngine;

public class CustomVideoPlayer : MonoBehaviour
{
    // 動画のURL
    [SerializeField] private string _url;
    
    // ミュート状態
    [SerializeField] private bool _isMuted;
    
    // レンダリング先のRenderTexture
    [SerializeField] private RenderTexture _targetRenderTexture;
    
    // 色空間をsRGBからLinearに変換するシェーダ
    [SerializeField] private Shader _sRGBToLinearShader;

    // 動画再生用のインスタンス
    private IVideoControl _videoControl;

    /// <summary>
    /// 動画を再生する
    /// </summary>
    public void Play()
    {
        _videoControl.Play();
    }

    /// <summary>
    /// 動画再生を停止する
    /// </summary>
    public void Stop()
    {
        _videoControl.Stop();
    }

    /// <summary>
    /// 動画再生を一時停止する
    /// </summary>
    public void Pause()
    {
        _videoControl.Pause();
    }

    /// <summary>
    /// コマ送りする
    /// </summary>
    public void StepForward()
    {
        _videoControl.StepForward();
    }
    
    /// <summary>
    /// 動画のURL
    /// </summary>
    public string URL
    {
        get => _videoControl.URL;
        set => _videoControl.URL = value;
    }

    /// <summary>
    /// 現在時刻[s]
    /// </summary>
    public double Time
    {
        get => _videoControl.Time;
        set => _videoControl.Time = value;
    }

    /// <summary>
    /// 動画の長さ[s]
    /// </summary>
    public double Duration => _videoControl.Duration;
    
    /// <summary>
    /// ミュート状態
    /// </summary>
    public bool IsMuted
    {
        get => _isMuted;
        set
        {
            _isMuted = value;
            _videoControl.IsMuted = value;
        }
    }

    private void Awake()
    {
        // WebGLビルド時はWebGLVideoControlを使用
        // それ以外の環境ではVideoPlayerControlを使用
#if !UNITY_EDITOR && UNITY_WEBGL
        _videoControl = new WebGLVideoControl(_url, _targetRenderTexture, _sRGBToLinearShader);
#else
        _videoControl = new VideoPlayerControl(gameObject, _url, _targetRenderTexture);
#endif
    }

    private void OnDestroy()
    {
        // 後処理
        _videoControl.Dispose();
    }

    private void Update()
    {
        // フレームの更新処理
        _videoControl.Update();
    }

#if UNITY_EDITOR
    private void OnValidate()
    {
        if (_videoControl == null) return;
        if (_videoControl.URL == _url) return;

        // URLが変更されていたら、新しいURLを設定する
        _videoControl.URL = _url;
    }
#endif
}

using TMPro;
using UnityEngine;
using UnityEngine.UI;

public class VideoControlUI : MonoBehaviour
{
    [SerializeField] private CustomVideoPlayer _videoPlayer;
    [SerializeField] private TMP_InputField _urlInputField;
    [SerializeField] private Slider _slider;
    [SerializeField] private TMP_Text _timeText;
    [SerializeField] private Toggle _muteToggle;

    private bool _isSeekingAutomatically;

    private void Start()
    {
        if (_videoPlayer == null) return;

        if (_urlInputField != null)
        {
            // 動画のURLをInputFieldに反映
            _urlInputField.text = _videoPlayer.URL;

            // 動画のURLが変更されたら、CustomVideoPlayerに反映
            _urlInputField.onEndEdit.AddListener(url => _videoPlayer.URL = url);
        }

        if (_slider != null)
        {
            // スライダーの値が変更されたら、動画の再生進捗を変更
            _slider.onValueChanged.AddListener(value =>
            {
                if (_isSeekingAutomatically) return;
                _videoPlayer.Time = value * _videoPlayer.Duration;
            });
        }

        if (_muteToggle != null)
        {
            // 最初にミュート設定を反映
            _muteToggle.isOn = _videoPlayer.IsMuted;
            
            // ミュート設定が変更されたら、CustomVideoPlayerに反映
            _muteToggle.onValueChanged.AddListener(isOn => _videoPlayer.IsMuted = isOn);
        }
    }

    // UIの更新処理
    private void Update()
    {
        if (_videoPlayer == null) return;
        if (_videoPlayer.Duration <= 0) return;

        // 動画の再生位置を取得
        var time = _videoPlayer.Time;

        if (_slider != null)
        {
            _isSeekingAutomatically = true;

            // 動画の再生進捗を計算
            var progress = Mathf.Clamp01((float) (time / _videoPlayer.Duration));

            // スライダーの値を更新
            if (!float.IsNaN(progress))
                _slider.value = progress;

            _isSeekingAutomatically = false;
        }

        if (_timeText != null)
        {
            // 動画の再生時間をテキストに反映
            var minutes = Mathf.FloorToInt((float) time / 60);
            var seconds = Mathf.FloorToInt((float) time % 60);
            _timeText.SetText("{0:00}:{1:00}", minutes, seconds);
        }
    }
}