C# AudioType類代碼示例

 public AudioClipInfo(AudioType type, string resourcename, string systemname, float initvolume, int maxSEcount = 16 )
 {
     ResourceName = resourcename;
     if (type == AudioType.SE)
     {
         ResourcePath = SEPath + resourcename;
     }
     else if (type == AudioType.BGM) {
         ResourcePath = BGMPath + resourcename;
     }
     SystemName = systemname;
     MaxSECount = maxSEcount;
     PlayingList = new List<SEInfo>(maxSEcount);
     StockList = new SortedList<int, SEInfo>(maxSEcount);
     InitVolume = initvolume;
     AttenuateRate = calcAttenuateRate();
     //Debug.Log("Att: " + AttenuateRate);
     for (int i = 0; i < MaxSECount; i++) {
         //Debug.LogFormat("InitVol:{0}",InitVolume);
         SEInfo seinfo = new SEInfo(i, 0f, InitVolume * Mathf.Pow(AttenuateRate, i));
         //SEInfo seinfo = new SEInfo(i, 0f, InitVolume);
         StockList.Add(seinfo.Index, seinfo);
         //Debug.Log("Vol: " + seinfo.Volume);
     }
     Loop = null;
 }

 public void PlayAudio(AudioType type)
 {
     foreach (var audio in AudioList.Where(audio => audio.type == type))
     {
         audio.Play();
     }
 }

 /**
 // \fn public Playlist(int id, string name, string filename, AudioType type)
 //
 // \brief Constructor.
 //
 // \author Simon Menetrey
 // \date 26.05.2014
 //
 // \param id       The identifier.
 // \param name     The name.
 // \param filename Filename of the file.
 // \param type     The type.
 **/
 public Playlist(int id, string name, string filename, AudioType type)
 {
     this.Id = id;
     this.Name = name;
     this.Filename = filename;
     this.Type = type;
     this.AudioFileList = new List<string>();
 }

 public void play(AudioSource source, AudioType type)
 {
     if (canPlay (type)) {
         source.PlayOneShot (source.clip);
         audiosPlaying [type] = audiosPlaying [type] + 1;
         StartCoroutine (decrementAudiosPlaying (type, source.clip.length));
     }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="LocalSong"/> class.
 /// </summary>
 /// <param name="path">The path of the file.</param>
 /// <param name="audioType">The audio type.</param>
 /// <param name="duration">The duration of the song.</param>
 public LocalSong(string path, AudioType audioType, TimeSpan duration)
     : base(path, audioType, duration)
 {
     if (this.IsRemovable)
     {
         this.StreamingPath = this.OriginalPath;
     }
 }

 private VideoInfo(int formatCode, VideoType videoType, int resolution, bool is3D, AudioType audioType, int audioBitrate)
 {
     this.FormatCode = formatCode;
     this.VideoType = videoType;
     this.Resolution = resolution;
     this.Is3D = is3D;
     this.AudioType = audioType;
     this.AudioBitrate = audioBitrate;
 }

 public AudioBinary(byte[] audioBytes, AudioType audioType)
 {
     if (audioBytes == null || audioBytes.Length < 1)
     {
         throw new InvalidOperationException("AudioBytes must contain values.");
     }
     AudioBytes = audioBytes;
     AudioType = audioType;
 }

 public Audio(string name, string saveName, int matchScriptID)
 {
     Name = name;
     MatchScriptID = matchScriptID;
     SaveName = saveName;
     LengthMillis = AudioHelper.GetAudioLength(saveName);
     Length = AudioHelper.ConvertMillisToTime(LengthMillis);
     Type = AudioHelper.GetAudioType(saveName);
 }

 private VideoInfo(int formatCode, VideoType videoType, int resolution, bool is3D, AudioType audioType, int audioBitrate)
 {
     FormatCode = formatCode;
     VideoType = videoType;
     Resolution = resolution;
     Is3D = is3D;
     AudioType = audioType;
     AudioBitrate = audioBitrate;
 }

        protected override int AddNewData()
        {
            m_audioType = DataManager.Generate<AudioType>();
            m_audioType.Name = m_textBox_name.Text;

            DataManager.AudioTypes.Add(m_audioType);

            return m_audioType.Id;
        }

        public static Mock<Song> CreateSongMock(string name = "Song", bool callBase = false, AudioType audioType = AudioType.Mp3, TimeSpan? duration = null)
        {
            if (duration == null)
            {
                duration = TimeSpan.Zero;
            }

            return new Mock<Song>(name, audioType, duration) { CallBase = callBase };
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="YoutubeSong"/> class.
        /// </summary>
        /// <param name="path">The path of the song.</param>
        /// <param name="audioType">The audio type.</param>
        /// <param name="duration">The duration of the song.</param>
        /// <param name="isStreaming">if set to true, the song streams from YouTube, instead of downloading.</param>
        /// <exception cref="ArgumentNullException"><c>path</c> is null.</exception>
        public YoutubeSong(string path, AudioType audioType, TimeSpan duration, bool isStreaming)
            : base(path, audioType, duration)
        {
            this.IsStreaming = isStreaming;

            if (this.IsStreaming)
            {
                this.StreamingPath = this.OriginalPath;
            }
        }

    public static AudioSource GetLatestAudioSource( AudioType audioType )
    {
        GameObject audioLayer = GetAudioLayer( audioType );

        AudioSource[] audioSources = audioLayer.GetComponents<AudioSource>() as AudioSource[];

        if( audioSources.Length > 0 )
            return audioSources[ audioSources.Length - 1 ];

        return audioLayer.AddComponent("AudioSource") as AudioSource;
    }

 public static void Play( AudioClip clip, AudioType type )
 {
     if( type == AudioType.SFX ) {
         instance.audioSFX.PlayOneShot( clip, 1f);
     }
     else if( type == AudioType.Music && clip != instance.audioMusic.clip ) {
         instance.audioMusic.loop = true;
         instance.audioMusic.volume = 0.5f;
         instance.audioMusic.clip = clip;
         instance.audioMusic.Play();
     }
 }

	public static bool IsMuted (AudioType audioType) {
		switch (audioType) {
		case AudioType.FX:
			return SettingsUtil.FXMuted;
		case AudioType.Music:
			return SettingsUtil.MusicMuted;
		case AudioType.VO:
			return SettingsUtil.VOMuted;
		default:
			throw new System.Collections.Generic.KeyNotFoundException();
		}
	}