【Unity】第一回 CRI ADXを使用したサウンド制御 〜基本動作、周波数解析編〜

    private CriAtomSource _atomSource;

    private void Start()
    {
        _atomSource = (CriAtomSource)GetComponent("CriAtomSource");
    }

    public void PlaySound()
    {
        _atomSource.Play();
    }

    private CriAtomExPlayer _atomExPlayer;

    private void Start()
    {
        _atomExPlayer = new CriAtomExPlayer();
    }

    public void PlaySound()
    {
        var atomExAcb = CriWare.CriAtom.GetAcb("[CueSheetName]");
        _atomExPlayer.SetCue(atomExAcb, "[CueName]");
        _atomExPlayer.Start();
    }

        /// <summary>
        /// CueSheet情報
        /// </summary>
        public class CueSheetInfo
        {
            /// <summary>
            /// CueSheet名
            /// </summary>
            public string Name;

            /// <summary>
            /// 初期化時にロードするか？
            /// </summary>
            public bool IsLoadOnInitialize;

            /// <summary>
            /// AWBファイルが存在するか？
            /// </summary>
            public bool IsExistAwbFile;

            /// <summary>
            /// ループ再生するか？
            /// </summary>
            public bool IsPlayLoop = false;
        }

        /// <summary>
        /// 生成したCueAtomExPlayerのキャッシュ
        /// key: CueSheet名, value: CueAtomExPlayer
        /// </summary>
        private readonly Dictionary<string, CriAtomExPlayer> _criAtomExPlayerCache = new Dictionary<string, CriAtomExPlayer>();

・・・略・・・

        /// <summary>
        /// CueSheetの登録
        /// </summary>
        /// <param name="cueSheetInfo">CueSheet情報</param>
        public void RegisterCueSheet(ICriAdxApiService.CueSheetInfo cueSheetInfo)
        {
            // CriAtomExPlayerの生成
            CreateCriAtomExPlayer(cueSheetInfo);

            // CueSheet情報を追加
            var cueSheetName = cueSheetInfo.Name;
            CriWare.CriAtom.AddCueSheet(
                cueSheetName,
                Path.Combine(_initializeSetting.AssetFilePath, $"{cueSheetName}.acb"),
                cueSheetInfo.IsExistAwbFile ? Path.Combine(_initializeSetting.AssetFilePath, $"{cueSheetName}.awb") : null);
        }

・・・略・・・

        /// <summary>
        /// CriAtomExPlayerの追加
        /// </summary>
        /// <param name="cueSheetInfo"></param>
        /// <returns></returns>
        private void CreateCriAtomExPlayer(ICriAdxApiService.CueSheetInfo cueSheetInfo)
        {
            if (cueSheetInfo == null || string.IsNullOrEmpty(cueSheetInfo.Name))
            {
                Debug.LogError($"invalid CreateCriAtomExPlayer parameters.");
                return;
            }

            // 既に生成済か？
            var cueSheetName = cueSheetInfo.Name;
            if (_criAtomExPlayerCache != null
                &&_criAtomExPlayerCache.ContainsKey(cueSheetName))
            {
                Debug.LogWarning($"already create CriAtomExPlayer => {cueSheetName}");
                return;
            }

            // CriAtomExPlayerを生成してキャッシュ
            var criAtomExPlayer = new CriAtomExPlayer();

            criAtomExPlayer.Loop(cueSheetInfo.IsPlayLoop);
            _criAtomExPlayerCache.TryAdd(cueSheetName, criAtomExPlayer);
        }

        /// <summary>
        /// CueSheetの削除
        /// </summary>
        /// <param name="cueSheetName">CueSheet名</param>
        public void RemoveCueSheet(string cueSheetName)
        {
            if (!_criAtomExPlayerCache.ContainsKey(cueSheetName))
            {
                return;
            }

            // CriAtomExPlayerの削除
            var criAtomPlayer = _criAtomExPlayerCache[cueSheetName];
            criAtomPlayer.Dispose();
            _criAtomExPlayerCache.Remove(cueSheetName);

            // 設定したCueSheet情報も削除
            CriWare.CriAtom.RemoveCueSheet(cueSheetName);
        }

        /// <summary>
        /// 指定したCueを再生する
        /// </summary>
        /// <param name="cueSheetName">CueSheet名</param>
        /// <param name="cueName">Cue名</param>
        /// <param name="option">再生オプション</param>
        public void Play(string cueSheetName, string cueName, ICriAdxApiService.SoundPlayOption option = null)
        {
            var criAtomExPlayer = GetCriAtomExPlayer(cueSheetName);
            if (criAtomExPlayer == null)
            {
                Debug.LogError($"not register CueSheet => {cueSheetName}");
                return;
            }

            // フェード設定を切り替える
            var fadeTime = option?.FadeTimeMs ?? 0;
            ChangeCriAtomExPlayerFadeSettings(criAtomExPlayer, fadeTime);
            if (fadeTime <= 0)
            {
                Stop(cueSheetName);
            }

            // オプションに応じて再生
            var atomExAcb = CriWare.CriAtom.GetAcb(cueSheetName);
            criAtomExPlayer.SetVolume(option?.Volume ?? 1f);
            criAtomExPlayer.SetPitch(option?.Pitch ?? 0f);
            criAtomExPlayer.SetCue(atomExAcb, cueName);

            var criAtomPlayback = criAtomExPlayer.Start();
            _criAtomPlaybackCache[cueName] = criAtomPlayback;
        }

・・・略・・・

        /// <summary>
        /// 指定したCueSheetの再生を停止する
        /// </summary>
        /// <param name="cueSheetName">CueSheet名</param>
        /// <param name="option">停止オプション</param>
        public void Stop(string cueSheetName, ICriAdxApiService.SoundStopOption option = null)
        {
            var criAtomExPlayer = GetCriAtomExPlayer(cueSheetName);
            if (criAtomExPlayer == null)
            {
                return;
            }

            // フェード設定を切り替える
            ChangeCriAtomExPlayerFadeSettings(criAtomExPlayer, option?.FadeTimeMs ?? 0);

            // CueSheetの再生を停止する
            criAtomExPlayer.Stop();
        }

        /// <summary>
        /// CriAtomExPlayerのフェード設定 キャッシュ情報
        /// </summary>
        private readonly Dictionary<CriAtomExPlayer, int> _currentFadeTimeMsCache = new Dictionary<CriAtomExPlayer, int>();

        /// <summary>
        /// CriAtomExPlayerのフェード設定を切り替える
        /// </summary>
        /// <param name="criAtomExPlayer">CriAtomExPlayer</param>
        /// <param name="fadeTimeMs">フェードさせる時間</param>
        private void ChangeCriAtomExPlayerFadeSettings(CriAtomExPlayer criAtomExPlayer, int fadeTimeMs = 0)
        {
            if (criAtomExPlayer == null)
            {
                return;
            }

            // 設定の変更がない場合は何も行わない
            var isFirstSettings = !_currentFadeTimeMsCache.ContainsKey(criAtomExPlayer);
            var currentFadeTime = isFirstSettings ? 0 : _currentFadeTimeMsCache[criAtomExPlayer];
            if (fadeTimeMs == currentFadeTime)
            {
                return;
            }

            // フェード設定を変更
            if (isFirstSettings)
            {
                criAtomExPlayer.AttachFader();
            }
            criAtomExPlayer.SetFadeInTime(fadeTimeMs);
            criAtomExPlayer.SetFadeOutTime(fadeTimeMs);
            _currentFadeTimeMsCache[criAtomExPlayer] = fadeTimeMs;
        }

        /// <summary>
        /// 指定したCueを再生する(3D位置再生)
        /// </summary>
        /// <param name="gameObject">対象GameObject</param>
        /// <param name="cueSheetName">CueSheet名</param>
        /// <param name="cueName">Cue名</param>
        /// <param name="option">再生オプション</param>
        public void Play3d(GameObject gameObject, string cueSheetName, string cueName, ICriAdxApiService.SoundPlayOption option = null)
        {
            // CriAtomSourceの生成
            var criAtomSource = gameObject.GetComponent<CriAtomSource>();
            if (criAtomSource == null)
            {
                criAtomSource = gameObject.AddComponent<CriAtomSource>();
                criAtomSource.cueSheet = cueSheetName;
                criAtomSource.use3dPositioning = true;
            }

            // フェード設定を切り替える
            var criAtomExPlayer = criAtomSource.player;
            ChangeCriAtomExPlayerFadeSettings(criAtomExPlayer, option?.FadeTimeMs ?? 0);

            // オプションに応じて再生
            criAtomSource.cueName = cueName;
            criAtomSource.volume = option?.Volume ?? 1f;
            criAtomSource.pitch = option?.Pitch ?? 0f;

            var criAtomPlayback = criAtomSource.Play();
            _criAtomPlaybackCache[cueName] = criAtomPlayback;
        }

        /// <summary>
        /// 指定バスのボリューム取得
        /// </summary>
        /// <param name="busName">バス名</param>
        /// <returns></returns>
        public float GetBusVolume(string busName)
        {
            CriAtomExAsr.GetBusVolume(busName, out var volume);
            return volume;
        }

        /// <summary>
        /// 指定バスのボリューム設定
        /// </summary>
        /// <param name="busName">バス名</param>
        /// <param name="volume">ボリューム</param>
        public void SetBusVolume(string busName, float volume) => CriAtomExAsr.SetBusVolume(busName, volume);

        /// <summary>
        /// 指定カテゴリのボリューム取得
        /// </summary>
        /// <param name="categoryName">カテゴリ名</param>
        /// <returns></returns>
        public float GetCategoryVolume(string categoryName) => CriWare.CriAtom.GetCategoryVolume(categoryName);

        /// <summary>
        /// 指定カテゴリのボリューム設定
        /// </summary>
        /// <param name="categoryName">カテゴリ名</param>
        /// <param name="volume">ボリューム</param>
        public void SetCategoryVolume(string categoryName, float volume) => CriWare.CriAtom.SetCategoryVolume(categoryName, volume);

        /// <summary>
        /// Masterボリューム
        /// </summary>
        public float MasterVolume
        {
            get => _criAdxApiService.GetBusVolume(GameCriAdxAudioSettings.CriAdx.BusName.Master);
            set => _criAdxApiService.SetBusVolume(GameCriAdxAudioSettings.CriAdx.BusName.Master, value);
        }

        /// <summary>
        /// BGMボリューム
        /// </summary>
        public float BgmVolume
        {
            get => _criAdxApiService.GetCategoryVolume(GameCriAdxAudioSettings.CriAdx.CategoryName.Bgm);
            set => _criAdxApiService.SetCategoryVolume(GameCriAdxAudioSettings.CriAdx.CategoryName.Bgm, value);
        }

        /// <summary>
        /// SEボリューム
        /// </summary>
        public float SeVolume
        {
            get => _criAdxApiService.GetCategoryVolume(GameCriAdxAudioSettings.CriAdx.CategoryName.Se);
            set => _criAdxApiService.SetCategoryVolume(GameCriAdxAudioSettings.CriAdx.CategoryName.Se, value);
        }

        /// <summary>
        /// DSPバスのスナップショットを切り替える
        /// </summary>
        /// <param name="snapshotName">スナップショット名</param>
        /// <param name="fadeTimeMs">フェードさせる時間</param>
        public void ChangeBusSnapshot(string snapshotName, int fadeTimeMs)
        {
            CriAtomEx.ApplyDspBusSnapshot(snapshotName, fadeTimeMs);
        }

        /// <summary>
        /// BGMエフェクト変更
        /// </summary>
        /// <param name="effectType">エフェクトタイプ</param>
        public void ChangeBgmEffect(IGameAudioService.EffectType effectType)
        {
            switch (effectType)
            {
                case IGameAudioService.EffectType.Normal:
                    _criAdxApiService.ChangeBusSnapshot(GameCriAdxAudioSettings.CriAdx.BusSnapshotName.Normal, 1000);
                    break;
                case IGameAudioService.EffectType.Reverb:
                    _criAdxApiService.ChangeBusSnapshot(GameCriAdxAudioSettings.CriAdx.BusSnapshotName.BgmReverb, 1000);
                    break;
                case IGameAudioService.EffectType.Distortion:
                    _criAdxApiService.ChangeBusSnapshot(GameCriAdxAudioSettings.CriAdx.BusSnapshotName.BgmDistortion, 1000);
                    break;
            }
        }

        /// <summary>
        /// スペクトラムアナライザ
        /// </summary>
        private CriAtomExOutputAnalyzer _spectrumAnalyzer;

        /// <summary>
        /// スペクトラムアナライザの設定
        /// CriAtomExPlayerを再生する前に紐づけておく必要がある
        /// </summary>
        /// <param name="cueSheetName">CueSheet名</param>
        /// <param name="sampleCount">サンプル数</param>
        public void SetSpectrumAnalyzer(string cueSheetName, int sampleCount)
        {
            if (!_criAtomExPlayerCache.ContainsKey(cueSheetName))
            {
                return;
            }
            var criAtomExPlayer = _criAtomExPlayerCache[cueSheetName];

            // 既に作成されていたらデタッチ、破棄する
            _spectrumAnalyzer?.DetachExPlayer();
            _spectrumAnalyzer?.Dispose();

            // スペクトラムアナライザ用の設定
            var config = new CriAtomExOutputAnalyzer.Config();
            config.enableSpectrumAnalyzer = true;
            config.numSpectrumAnalyzerBands = sampleCount;
            _spectrumAnalyzer = new CriAtomExOutputAnalyzer(config);
            _spectrumAnalyzer.AttachExPlayer(criAtomExPlayer);
        }

        /// <summary>
        /// スペクトラムアナライザから周波数データを取得する
        /// </summary>
        /// <param name="sampleCount">サンプル数</param>
        /// <param name="isConvertDecibel">デシベル値に変換するか？</param>
        /// <returns></returns>
        public float[] GetSpectrumData(int sampleCount, bool isConvertDecibel)
        {
            var result = new float[sampleCount];
            if (_spectrumAnalyzer == null)
            {
                Debug.LogError("not called 'CreateSpectrumAnalyzer' method.");
                return result;
            }

            // 周波数データを取得
            _spectrumAnalyzer.GetSpectrumLevels(ref result);

            // デシベルに変換
            // https://game.criware.jp/manual/unity_plugin/latest/contents/classCriWare_1_1CriAtomExOutputAnalyzer.html#a6b99d6b5310af38efe20ff834c59c4e0
            if (isConvertDecibel)
            {
                result = result.Select((value) =>
                {
                    if (value <= Mathf.Epsilon)
                    {
                        return 0f;
                    }
                    return 20.0f * Mathf.Log10(value);
                }).ToArray();
            }

            return result;
        }

        /// <summary>
        /// スペクトラムアナライザの設定
        /// </summary>
        /// <param name="eventName">サウンドイベント名</param>
        /// <param name="sampleCount">サンプル数</param>
        /// <returns>作成に成功したか？</returns>
        public bool SetSpectrumAnalyzer(string eventName, int sampleCount)
        {
            _criAdxApiService.SetSpectrumAnalyzer(GameCriAdxAudioSettings.CriAdx.GetCueSheetName(eventName), sampleCount);
            return true;
        }

        /// <summary>
        /// スペクトラムアナライザから周波数データを取得する
        /// </summary>
        /// <param name="sampleCount">サンプル数</param>
        /// <param name="isConvertDecibel">デシベル値に変換するか？</param>
        /// <returns></returns>
        public float[] GetSpectrumData(int sampleCount, bool isConvertDecibel)
        {
            return _criAdxApiService.GetSpectrumData(sampleCount, isConvertDecibel);
        }