// Update is called once per frame
void Update()
{
//creates the link (via the variable audio) to access the game object's base component, in this case the Audio Source
AudioSource audio = GetComponent <AudioSource>();
AudioHighPassFilter highpass = GetComponent <AudioHighPassFilter>();
AudioLowPassFilter lowpass = GetComponent <AudioLowPassFilter>();
positionx = GetComponent <Transform>().position.x;
positiony = GetComponent <Transform>().position.y;
positionz = GetComponent <Transform>().position.z;
scalez = GetComponent <Transform>().lossyScale.z;
audio.pitch = scalez * 5;
if (-2f < positionx && positionx <= 2f)
{
float v = ((positionx + 2f) * lowmod);
lowpass.cutoffFrequency = lowbase + v;
}
if (-2f < positionz && positionz <= 2f)
{
float x = ((positionz + 2f) * highmod);
highpass.cutoffFrequency = highbase + x;
}
if (0f < positiony && positiony <= 2f)
{
audio.volume = positiony - .1f;
}
}
private void Start()
{
listener = GameObject.Find("CenterEyeAnchor");
lowPassFilter = listener.GetComponent <AudioLowPassFilter>();
highPassFilter = listener.GetComponent <AudioHighPassFilter>();
reverbFilter = listener.GetComponent <AudioReverbFilter>();
}
public void Start()
{
var listenerObject = GameObject.FindGameObjectWithTag("Listener");
targetLowPassFilter = listenerObject.GetComponent <AudioLowPassFilter>();
targetHighPassFilter = listenerObject.GetComponent <AudioHighPassFilter>();
}
private void Awake()
{
audioSource = this.GetComponent <AudioSource>();
if (!audioSource)
{
audioSource = this.gameObject.AddComponent <AudioSource>();
}
audioSource.spatialBlend = 1;
audioSource.playOnAwake = false;
audioSource.spatialize = true;
lowPassFilter = this.GetComponent <AudioLowPassFilter>();
if (!lowPassFilter)
{
lowPassFilter = this.gameObject.AddComponent <AudioLowPassFilter>();
}
lowPassFilter.enabled = false;
highPassFilter = this.GetComponent <AudioHighPassFilter>();
if (!highPassFilter)
{
highPassFilter = this.gameObject.AddComponent <AudioHighPassFilter>();
}
highPassFilter.enabled = false;
reverbFilter = this.GetComponent <AudioReverbFilter>();
if (!reverbFilter)
{
reverbFilter = this.gameObject.AddComponent <AudioReverbFilter>();
}
reverbFilter.reverbPreset = AudioReverbPreset.Off;
reverbFilter.enabled = false;
}
public static void Init()
{
audioSoundsGameObjects.Clear();
currentPlaingAudioSounds.Clear();
Transform soundsContainer = GameObject.Find("SoundPlayersContainer").transform;
for (int i = 0; i < 40; i++)
{
GameObject _gameObj = new GameObject("Sound", typeof(AudioSource), typeof(AudioHighPassFilter));
AudioHighPassFilter audioHighPassFilter = _gameObj.GetComponent <AudioHighPassFilter>();
_gameObj.GetComponent <AudioSource>().playOnAwake = false;
audioHighPassFilter.cutoffFrequency = 2000;
audioHighPassFilter.highpassResonanceQ = 4;
audioHighPassFilter.enabled = false;
_gameObj.transform.SetParent(soundsContainer);
_gameObj.SetActive(false);
audioSoundsGameObjects.Enqueue(_gameObj);
}
ITakeDmg takeDmg;
foreach (var item in BirdContainerController.GetInstance.birds.Values)
{
item.TryGetComponent <ITakeDmg>(out takeDmg);
if (takeDmg != null)
{
item.GetComponent <ITakeDmg>().OnDie += () => backMusic.GetComponent <AudioHighPassFilter>().enabled = true;
}
}
}
public override void Init()
{
m_audioSource = this.GetComponent <AudioSource>();
m_highPassFilter = GetComponent <AudioHighPassFilter>();
m_childObj = new GameObject[CHILD_COUNT];
for (int i = 0; i < CHILD_COUNT; i++)
{
GameObject empty = new GameObject("EmptyClip");
empty.AddComponent <AudioSource>();
empty.transform.parent = transform;
m_childObj[i] = empty;
}
if (m_AudioClips.Length != 0)
{
for (int i = 0; i < m_AudioClips.Length; i++)
{
if (m_AudioClips[i] != null)
{
arr_AudioClip.Add(m_AudioClips[i].name, m_AudioClips[i]);
}
}
}
m_soundPlayData = new SoundPlayData();
m_soundPlayDataEft = new SoundPlayData();
}
void Start()
{
lowPassFilter = GetComponent <AudioLowPassFilter>();
lowPassFilter.cutoffFrequency = 22000;
hiPassFilter = GetComponent <AudioHighPassFilter>();
hiPassFilter.cutoffFrequency = 0;
}
public void SetChar(CharacterComponent myChar)
{
this.audioChar = myChar;
this.myAudioSource = this.audioChar.GetAudioSource(CharacterComponent.AudioSourceType.Character);
highPassFilter = this.myAudioSource.gameObject.GetComponent <AudioHighPassFilter>();
lowPassFilter = this.myAudioSource.gameObject.GetComponent <AudioLowPassFilter>();
distortion = this.myAudioSource.gameObject.GetComponent <AudioDistortionFilter>();
if (!highPassFilter)
{
highPassFilter = this.myAudioSource.gameObject.AddComponent <AudioHighPassFilter>();
}
if (!lowPassFilter)
{
lowPassFilter = this.myAudioSource.gameObject.AddComponent <AudioLowPassFilter>();
}
if (!distortion)
{
distortion = this.myAudioSource.gameObject.AddComponent <AudioDistortionFilter>();
}
highPassFilter.cutoffFrequency = Main.ruVoiceSettings.highPassFilterValue;
lowPassFilter.cutoffFrequency = Main.ruVoiceSettings.lowPassFilterValue;
lowPassFilter.lowpassResonanceQ = Main.ruVoiceSettings.lowpassResonanceQValue;
highPassFilter.cutoffFrequency = Main.ruVoiceSettings.highPassFilterCutoffFrequencyValue;
distortion.distortionLevel = Main.ruVoiceSettings.distortionFilterValue;
this.SetAudioPitch();
this.SetAudioVolume();
}
public override void SetupOn(AudioSource source)
{
AudioHighPassFilter orMakeFilterOn = SoundFilter.GetOrMakeFilterOn <AudioHighPassFilter>(source);
orMakeFilterOn.cutoffFrequency = this.cutoffFrequency;
orMakeFilterOn.highpassResonanceQ = this.highpassResonanceQ;
}
//the audio settings to change from either mono to stereo
public void AuSettings()
{
if (!isPlaying)
{//checking if an animation is playing
if (!isPlaying)
{
Text audioText = GameObject.Find("Canvas/Pause/Menus/AudioMenus/Audio").GetComponent <Text>();
switch (audioSettings)
{//determining which audio setting is currently being set
default:
audioSettings = AudioSettings.Stereo;
audioText.text = "Stereo";
gameObject.GetComponent <AudioHighPassFilter>().enabled = false;
AudioHighPassFilter sound = GameObject.Find("Game Manager/Sound").GetComponent <AudioHighPassFilter>();
sound.enabled = false;
sound = GameObject.Find("Game Manager/Music").GetComponent <AudioHighPassFilter>();
sound.enabled = false;
break;
case AudioSettings.Stereo:
audioSettings = AudioSettings.Mono;
audioText.text = "Mono";
gameObject.GetComponent <AudioHighPassFilter>().enabled = true;
sound = GameObject.Find("Game Manager/Sound").GetComponent <AudioHighPassFilter>();
sound.enabled = true;
sound = GameObject.Find("Game Manager/Music").GetComponent <AudioHighPassFilter>();
sound.enabled = true;
break;
}
_audio.pitch = 1.2f;
_audio.PlayOneShot(select, SFXvolume);
}
}
}
// Use this for initialization
void Start()
{
//Find the player/listener
listener = GameObject.Find("FirstPersonCharacter");
lpFilter = GetComponent <AudioLowPassFilter> ();
hpFilter = GetComponent <AudioHighPassFilter> ();
sphereSound = GetComponent <AudioSource> ();
/*
* 1. Make our Collider a trigger
* 2. Make it in same place as our source
* 3. Audio Sources are Circular thus 3D curve is radius. thus size should be 2 * Radius (Essentially the diameter)
*/
TriggerBox.isTrigger = true;
TriggerBox.transform.position = transform.position;
TriggerBox.size = new Vector3((maxAudioDistance * 2f), (maxAudioDistance * 2f), (maxAudioDistance * 2f));
//Play the sound file, loop it, and specify volume. Change at will
sphereSound.loop = true;
//High Pass filter will kick in for the last 1/3rd distance away (as compared to max 3D Audio attenuation Curve)
//Also Change .3f to whatever you wish.
hpfdist = maxAudioDistance * .3f;
hpfstartdist = maxAudioDistance - hpfdist;
}
private void Start()
{
menu_gameobject = main_canvas.transform.Find("Menu").gameObject;
audioS = GetComponent <AudioSource>();
audioFilterHigh = GetComponent <AudioHighPassFilter>();
Invoke("GenerateRandomLevel", 0.01f);
CheckPlayerPrefs();
Time.timeScale = startTimeScale;
}
// Use this for initialization
void Start()
{
listener = GameObject.Find("Player");
source = gameObject.GetComponent <AudioSource>();
lpFilter = gameObject.GetComponent <AudioLowPassFilter>();
hpFilter = gameObject.GetComponent <AudioHighPassFilter>();
source.playOnAwake = true;
}
public void Highpass(bool state = true)
{
if (!highpass)
{
highpass = Camera.main.GetComponent <AudioHighPassFilter>();
}
doingHighpass = state;
doingLowpass = false;
}
private void save_shared_settings_filter(ConfigNode node, AudioHighPassFilter highPassFilter)
{
ConfigNode _filter = new ConfigNode();
_filter.AddValue("enabled", highPassFilter.enabled);
_filter.AddValue("cutoff_freq", highPassFilter.cutoffFrequency);
_filter.AddValue("resonance_q", highPassFilter.highpassResonanceQ);
node.SetNode("HIGHPASS", _filter, true);
}
/// <summary>
/// Adds High Pass Filter to audiosource. Used for turbo.
/// </summary>
public static void NewHighPassFilter(AudioSource source, float freq, int level){
if(source == null)
return;
AudioHighPassFilter highFilter = source.gameObject.AddComponent<AudioHighPassFilter>();
highFilter.cutoffFrequency = freq;
highFilter.highpassResonanceQ = level;
}
// Start is called before the first frame update
void Start()
{
MLInput.Start();
_controller = MLInput.GetController(MLInput.Hand.Left);
hpf = GetComponent <AudioHighPassFilter>();
lpf = GetComponent <AudioLowPassFilter>();
active = false;
currentPosx = 1;
currentPosY = 0;
}
public override UnityEngine.Component CreateComponent(GameObject gameObject)
{
AudioHighPassFilter audioHighPassFilter = gameObject.GetComponent <AudioHighPassFilter>();
if (audioHighPassFilter == null)
{
audioHighPassFilter = gameObject.AddComponent <AudioHighPassFilter>();
}
return(audioHighPassFilter);
}
private void Start()
{
PauseMenu = GameObject.Find("PauseMenu");
PauseMenu.SetActive(false);
SettingsMenu.SetActive(false);
audioHighPassFilter = gameObject.GetComponent <AudioHighPassFilter>();
audioHighPassFilter.cutoffFrequency = 10;
obstacleDelaySlider.SetValueWithoutNotify(0.7f);
hitCountText.text = "0";
}
public IEnumerator HighPassDeathEffect()
{
AudioHighPassFilter hipass = gameObject.AddComponent <AudioHighPassFilter>();
hipass.cutoffFrequency = 1000f;
for (int i = 0; i < 100; i++)
{
hipass.highpassResonanceQ = (float)(i) / 50.0f;
yield return(new WaitForSeconds(0.05f));
}
}
private void Awake()
{
LoadQualityFilterSettings();
filterSettings = sourceQualityFilterSettings[SourceQuality];
lowPassFilter = gameObject.GetComponent <AudioLowPassFilter>();
lowPassFilter.cutoffFrequency = filterSettings.LowPassCutoff;
highPassFilter = gameObject.GetComponent <AudioHighPassFilter>();
highPassFilter.cutoffFrequency = filterSettings.HighPassCutoff;
}
private void Awake()
{
instance = this;
gameOver += GameOver;
source = GetComponent<AudioSource>();
highpass = GetComponent<AudioHighPassFilter>();
lowpass = GetComponent<AudioLowPassFilter>();
source.clip = clip;
anim = GetComponent<Animator>();
}
public static SAudioHighPassFilter Serialize(this AudioHighPassFilter _audioHighPassFilter)
{
SAudioHighPassFilter returnVal = new SAudioHighPassFilter
{
ExistsOnObject = (_audioHighPassFilter == null) ? false : true,
Enabled = _audioHighPassFilter.enabled,
cutoffFrequency = _audioHighPassFilter.cutoffFrequency,
highpassResonanceQ = _audioHighPassFilter.highpassResonanceQ,
};
return(returnVal);
}
private IEnumerator PrevRegionCoroutine()
{
AudioHighPassFilter filter = this.GetComponent <AudioHighPassFilter>();
filter.enabled = true;
for (float f = 0.0f; f < 1.0f; f += Time.deltaTime / pitchChangeTime)
{
filter.cutoffFrequency = previousPitchChangeCurve.Evaluate(f) * 100;
yield return(new WaitForEndOfFrame());
}
source.pitch = 1;
filter.enabled = false;
}
private void Start()
{
_audioFarFilter = _audioFar.GetComponent <AudioLowPassFilter>();
_audioMiddleFilter = _audioMiddle.GetComponent <AudioHighPassFilter>();
_audioCloseFilter = _audioClose.GetComponent <AudioHighPassFilter>();
// Schedule the audio clips to play slightly in the future so they have time to sync.
double startTime = AudioSettings.dspTime + 0.01;
_audioClose.PlayScheduled(startTime);
_audioMiddle.PlayScheduled(startTime);
_audioFar.PlayScheduled(startTime);
}
// Use this for initialization
void Start()
{
//gyro_status_first
g_x = 0;
g_y = 0;
back_x = 0;
back_y = 0;
//get_Inputcheck
Input = GameObject.Find("InputCheck");
//get_filter
low = gameObject.GetComponent <AudioLowPassFilter> ();
high = gameObject.GetComponent <AudioHighPassFilter> ();
}
private void Awake()
{
initialAudioSourceVolume = audioSource.volume;
// Get optional filters (and initial values) that the sound designer / developer
// may have applied to this game object
lowPassFilter = gameObject.GetComponent <AudioLowPassFilter>();
nativeLowPassCutoffFrequency = (lowPassFilter != null) ? lowPassFilter.cutoffFrequency : NeutralHighFrequency;
highPassFilter = gameObject.GetComponent <AudioHighPassFilter>();
nativeHighPassCutoffFrequency = (highPassFilter != null) ? highPassFilter.cutoffFrequency : NeutralLowFrequency;
// Preallocate the array that will be used to collect RaycastHit structures.
hits = new RaycastHit[maxObjects];
}
public static AudioHighPassFilter Deserialize(this SAudioHighPassFilter _audioHighPassFilter, ref GameObject _gameObject)
{
if (_audioHighPassFilter.ExistsOnObject == false)
{
return(null);
}
AudioHighPassFilter returnVal = _gameObject.GetComponent <AudioHighPassFilter>();
returnVal.enabled = _audioHighPassFilter.Enabled;
returnVal.cutoffFrequency = _audioHighPassFilter.cutoffFrequency;
returnVal.highpassResonanceQ = _audioHighPassFilter.highpassResonanceQ;
return(returnVal);
}
private void load_shared_settings_filter(ConfigNode node, AudioHighPassFilter highPassFilter)
{
if (node.HasValue("enabled"))
{
highPassFilter.enabled = Boolean.Parse(node.GetValue("enabled"));
}
if (node.HasValue("cutoff_freq"))
{
highPassFilter.cutoffFrequency = Single.Parse(node.GetValue("cutoff_freq"));
}
if (node.HasValue("resonance_q"))
{
highPassFilter.highpassResonanceQ = Single.Parse(node.GetValue("resonance_q"));
}
}
public void SetFilters(AudioManagerCategory cat)
{
if (cat.UseLowPassFilter)
{
AudioLowPassFilter filter = EnableFilter <AudioLowPassFilter>(EAudioFilter.LowPass);
cat.AudioFilters.LowPass.SetToFilter(filter);
}
if (cat.UseHighPassFilter)
{
AudioHighPassFilter filter = EnableFilter <AudioHighPassFilter>(EAudioFilter.HighPass);
cat.AudioFilters.HighPass.SetToFilter(filter);
}
if (cat.UseChorusFilter)
{
AudioChorusFilter filter = EnableFilter <AudioChorusFilter>(EAudioFilter.Chorus);
cat.AudioFilters.Chorus.SetToFilter(filter);
}
if (cat.UseDistortionFilter)
{
AudioDistortionFilter filter = EnableFilter <AudioDistortionFilter>(EAudioFilter.Distortion);
cat.AudioFilters.Distortion.SetToFilter(filter);
}
if (cat.UseEchoFilter)
{
AudioEchoFilter filter = EnableFilter <AudioEchoFilter>(EAudioFilter.Echo);
cat.AudioFilters.Echo.SetToFilter(filter);
}
if (cat.UseReverbFilter)
{
AudioReverbFilter filter = EnableFilter <AudioReverbFilter>(EAudioFilter.Reverb);
cat.AudioFilters.Reverb.SetToFilter(filter);
}
if (cat.UseFadeIn)
{
m_FadeInData = cat.AudioFilters.FadeIn;
}
if (cat.UseFadeOut)
{
m_FadeOutData = cat.AudioFilters.FadeOut;
}
}
