【Unity】hls.jsを用いてWebGL環境でHLS動画を再生する

const VideoPlayerOverride = {
    $isHLSInitialized: false,

    JS_Video_InitializeHLS__proxy: 'sync',
    JS_Video_InitializeHLS__sig: 'v',
    JS_Video_InitializeHLS__deps: ['$isHLSInitialized'],
    JS_Video_InitializeHLS: function () {
        if (isHLSInitialized) {
            return;
        }

        const script = document.createElement('script');
        script.src = 'https://cdn.jsdelivr.net/npm/hls.js@1';
        document.head.appendChild(script);

        script.onload = function () {
            isHLSInitialized = true;
        }
    },

    JS_Video_IsHlsInitialized__deps: ['$isHLSInitialized'],
    JS_Video_IsHlsInitialized__proxy: 'sync',
    JS_Video_IsHlsInitialized__sig: 'i',
    JS_Video_IsHlsInitialized: function () {
        return isHLSInitialized;
    },

    JS_Video_Create__proxy: 'sync',
    JS_Video_Create__sig: 'ii',
    JS_Video_Create__deps: ['$videoInstances', '$videoInstanceIdCounter', '$jsVideoEnded', '$hasSRGBATextures', '$UTF8ToString', '$isHLSInitialized'],
    JS_Video_Create: function (url) {
        var str = UTF8ToString(url);
        var video = document.createElement('video');
        video.style.display = 'none';
        video.src = str;
        video.muted = true;
        video.setAttribute("muted", "");
        video.setAttribute("playsinline", "");

        video.crossOrigin = "anonymous";

        if (isHLSInitialized && str.endsWith('.m3u8')) {
            if (Hls.isSupported()) {
                var hls = new Hls();
                hls.loadSource(str);
                hls.attachMedia(video);
            }
        }

        videoInstances[++videoInstanceIdCounter] = video;

        if (hasSRGBATextures == null)
            hasSRGBATextures = Module.SystemInfo.browser == "Chrome" || Module.SystemInfo.browser == "Edge";

        return videoInstanceIdCounter;
    },
};
autoAddDeps(VideoPlayerOverride, '$videoInstances');
autoAddDeps(VideoPlayerOverride, '$isHLSInitialized');
mergeInto(LibraryManager.library, VideoPlayerOverride);

using System.Collections;
using System.Runtime.InteropServices;
using UnityEngine;
using UnityEngine.Video;

public class VideoPlayerExample : MonoBehaviour
{
    // 動画再生用のVideoPlayer
    [SerializeField] private VideoPlayer _videoPlayer;

    // ビルド対象がWebGLの場合はJavaScript関数を呼び出す
#if UNITY_WEBGL && !UNITY_EDITOR
    [DllImport("__Internal")]
    private static extern void JS_Video_InitializeHLS();

    [DllImport("__Internal")]
    private static extern bool JS_Video_IsHlsInitialized();
    
    [DllImport("__Internal")]
    private static extern bool JS_Video_CanPlayFormat(string format);
#else
    // ビルド対象がWebGL以外の場合は空の関数を定義

    private static void JS_Video_InitializeHLS()
    {
    }

    private static bool JS_Video_IsHlsInitialized() => true;

    private static bool JS_Video_CanPlayFormat(string format)　=> true;
#endif

    // hls.jsを初期化してから動画を再生する
    private IEnumerator Start()
    {
        // いったんVideoPlayerを無効化
        _videoPlayer.enabled = false;

        if (JS_Video_CanPlayFormat("application/vnd.apple.mpegurl"))
        {
            // ネイティブでHLS動画を再生可能なので、そのまま再生
            _videoPlayer.enabled = true;
            _videoPlayer.Play();
            yield break;
        }

        // hls.jsの初期化
        JS_Video_InitializeHLS();

        // hls.jsの初期化が完了するまで待機
        yield return new WaitUntil(JS_Video_IsHlsInitialized);

        // VideoPlayerを有効化して再生
        _videoPlayer.enabled = true;
        _videoPlayer.Play();
    }
}

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

    $webGLVideoControlHlsJsLoading: false,
    $webGLVideoControlHlsJsLoaded: false,
    $webGLVideoControlPendingHlsInstances: [],

    $WebGLVideoControl_InitializeHlsJs: function () {
        if (webGLVideoControlHlsJsLoading || webGLVideoControlHlsJsLoaded) {
            return;
        }

        const video = document.createElement('video');
        if (video.canPlayType('application/vnd.apple.mpegurl') === '') {
            const script = document.createElement('script');
            script.src = 'https://cdn.jsdelivr.net/npm/hls.js@1';
            document.head.appendChild(script);

            script.onload = function () {
                webGLVideoControlHlsJsLoaded = true;
                webGLVideoControlHlsJsLoading = false;

                for (let i = 0; i < webGLVideoControlPendingHlsInstances.length; i++) {
                    const video = webGLVideoControlPendingHlsInstances[i];
                    const hls = new Hls();
                    hls.loadSource(video.src);
                    hls.attachMedia(video);
                }

                webGLVideoControlPendingHlsInstances = [];
            }
        }

        webGLVideoControlHlsJsLoading = true;
    },

    WebGLVideoControl_Create: function (url) {
        url = UTF8ToString(url);
        const video = document.createElement('video');
        video.style.display = 'none';
        video.src = url;

        if (url.endsWith('.m3u8')) {
            if (webGLVideoControlHlsJsLoaded) {
                if (Hls.isSupported()) {
                    const hls = new Hls();
                    hls.loadSource(url);
                    hls.attachMedia(video);
                }
            } else {
                webGLVideoControlPendingHlsInstances.push(video);
                WebGLVideoControl_InitializeHlsJs();
            }
        }

        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_IsReady: function (id) {
        const video = webGLVideoControlInstances[id];
        const targetReadyState = /(iPhone|iPad)/i.test(navigator.userAgent)
            ? video.HAVE_METADATA
            : video.HAVE_ENOUGH_DATA;
        return video.readyState >= targetReadyState;
    },

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

        const promise = video.play();

        if (promise !== undefined) {
            promise.catch(error => {
                if (error.name === 'NotAllowedError') {
                    const retryPlay = () => {
                        video.play().then(() => {
                            document.removeEventListener('mousedown', retryPlay);
                            document.removeEventListener('touchstart', retryPlay);
                        }).catch(error => {
                            console.error(error);
                        });
                    };

                    document.addEventListener('mousedown', retryPlay);
                    document.addEventListener('touchstart', retryPlay);
                }
            });
        }
    },

    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');
autoAddDeps(WebGLVideoControl, '$webGLVideoControlHlsJsLoading');
autoAddDeps(WebGLVideoControl, '$webGLVideoControlHlsJsLoaded');
autoAddDeps(WebGLVideoControl, '$webGLVideoControlPendingHlsInstances');
autoAddDeps(WebGLVideoControl, '$WebGLVideoControl_InitializeHlsJs');
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();
}

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 bool WebGLVideoControl_IsReady(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);

    // レンダリング対象のマテリアル
    private Material _targetMaterial;

    // レンダリング対象のRenderTexture
    private RenderTexture _targetRenderTexture;

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

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

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

    // ミュート状態
    private bool _isMuted;

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

    // 動画再生待機中かどうか
    private bool _isWaitingForReady;

    /// <summary>
    /// コンストラクタ
    /// </summary>
    /// <param name="url">動画のURL</param>
    /// <param name="targetRenderer">レンダリング対象のRenderer</param>
    /// <param name="sRGBToLinearShader">sRGBからLinearに変換するためのシェーダー</param>
    public WebGLVideoControl(string url, Renderer targetRenderer, Shader sRGBToLinearShader)
    {
        // 引数を保持
        _targetMaterial = targetRenderer.material;
        _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 (_targetMaterial != null)
        {
            Object.Destroy(_targetMaterial);
            _targetMaterial = null;
        }

        if (_sRGBToLinearMaterial != null)
        {
            Object.Destroy(_sRGBToLinearMaterial);
            _sRGBToLinearMaterial = null;
        }
    }

    /// <summary>
    /// 動画を再生する
    /// </summary>
    public void Play()
    {
        if (!WebGLVideoControl_IsReady(_videoInstanceID))
        {
            _isWaitingForReady = true;
            return;
        }

        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()
    {
        // 再生待機中かつ動画が準備完了したら再生
        if (_isWaitingForReady && WebGLVideoControl_IsReady(_videoInstanceID))
        {
            WebGLVideoControl_Play(_videoInstanceID, _isMuted);
            _isWaitingForReady = false;
        }

        // 動画の解像度を取得
        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);

            if (_targetRenderTexture != null)
            {
                Object.Destroy(_targetRenderTexture);
                _targetRenderTexture = null;
            }

            _targetRenderTexture =
                new RenderTexture(_videoResolution.x, _videoResolution.y, 0, RenderTextureFormat.ARGB32);

            // テクスチャをレンダリング対象のRendererに設定
            _targetMaterial.mainTexture = _targetRenderTexture;
        }

        WebGLVideoControl_UpdateToTexture(_videoInstanceID, _texture.GetNativeTexturePtr());

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

#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="targetRenderer">動画のレンダリング対象のRenderer</param>
    public VideoPlayerControl(GameObject videoPlayerObject, string url, Renderer targetRenderer)
    {
        // VideoPlayerコンポーネントを作成して初期化
        _videoPlayer = videoPlayerObject.AddComponent<VideoPlayer>();
        _videoPlayer.playOnAwake = false;
        _videoPlayer.url = url;
        _videoPlayer.source = VideoSource.Url;
        _videoPlayer.renderMode = VideoRenderMode.MaterialOverride;
        _videoPlayer.targetMaterialRenderer = targetRenderer;
    }

    /// <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 UnityEngine;

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

    // ミュート状態
    [SerializeField] private bool _isMuted;

    // Awake時に再生するかどうか
    [SerializeField] private bool _playOnAwake;

    // レンダリング先のRenderer
    [SerializeField] private Renderer _targetRenderer;

    // 色空間を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, _targetRenderer, _sRGBToLinearShader);
#else
        _videoControl = new VideoPlayerControl(gameObject, _url, _targetRenderer);
#endif

        if (_playOnAwake) Play();
    }

    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
}

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
        }
    }
}