Example #1
0
        public void SetSpatializer(VRC_SpatialAudioSource obj)
        {
            spatialAudioSource_ = obj;
            audioSource_        = GetComponent <AudioSource>();
            onsp_ = this;

            UpdateSettings();
        }
Example #2
0
        private void LimitAudioSource(AudioSource audioSource)
        {
            audioSource.spatialBlend = 1;

            if (audioSource.minDistance > Config.MaxAudioDistance.Value)
            {
                audioSource.minDistance = Config.MaxAudioDistance.Value;
            }

            if (audioSource.maxDistance > Config.MaxAudioDistance.Value)
            {
                audioSource.maxDistance = Config.MaxAudioDistance.Value;
            }

            VRC_SpatialAudioSource spatialSource = audioSource.GetComponent <VRC_SpatialAudioSource>();

            if (spatialSource == null)
            {
                return;
            }

            ONSPAudioSource onspSource = spatialSource.GetComponent <ONSPAudioSource>();

            if (onspSource != null)
            {
                onspSource.enableSpatialization = true;
                if (onspSource.far > Config.MaxAudioDistance.Value)
                {
                    onspSource.far = Config.MaxAudioDistance.Value;
                }

                if (onspSource.volumetricRadius > Config.MaxAudioDistance.Value)
                {
                    onspSource.volumetricRadius = Config.MaxAudioDistance.Value;
                }

                if (onspSource.near > Config.MaxAudioDistance.Value)
                {
                    onspSource.near = Config.MaxAudioDistance.Value;
                }
            }

            spatialSource.EnableSpatialization = true;
            if (spatialSource.Far > Config.MaxAudioDistance.Value)
            {
                spatialSource.Far = Config.MaxAudioDistance.Value;
            }

            if (spatialSource.VolumetricRadius > Config.MaxAudioDistance.Value)
            {
                spatialSource.VolumetricRadius = Config.MaxAudioDistance.Value;
            }

            if (spatialSource.Near > Config.MaxAudioDistance.Value)
            {
                spatialSource.Near = Config.MaxAudioDistance.Value;
            }
        }
        private void UpdateSettings()
        {
            if (spatialAudioSource_ == null)
            {
                spatialAudioSource_ = GetComponent <VRC_SpatialAudioSource>();
                if (spatialAudioSource_ == null)
                {
                    Destroy(this);
                }
                SetSpatializer(spatialAudioSource_);
                return;
            }

            // Check if we need to make changes.
            if (
                onsp_.EnableSpatialization != spatialAudioSource_.EnableSpatialization ||
                onsp_.Gain != spatialAudioSource_.Gain ||
                onsp_.Near != spatialAudioSource_.Near ||
                onsp_.Far != spatialAudioSource_.Far ||
                useAudioSourceCurve != spatialAudioSource_.UseAudioSourceVolumeCurve
                )
            {
                forceUpdate_ = true;
            }

            onsp_.EnableSpatialization = spatialAudioSource_.EnableSpatialization;
            onsp_.Gain             = spatialAudioSource_.Gain;
            useAudioSourceCurve    = spatialAudioSource_.UseAudioSourceVolumeCurve;
            onsp_.Near             = spatialAudioSource_.Near;
            onsp_.Far              = spatialAudioSource_.Far;
            onsp_.VolumetricRadius = spatialAudioSource_.VolumetricRadius;

            onsp_.SetParameters(ref audioSource_);

            if (!onsp_.EnableSpatialization)
            {
                return;
            }

            if (!forceUpdate_)
            {
                return;
            }

            forceUpdate_ = false;

            if (!spatialAudioSource_.UseAudioSourceVolumeCurve)
            {
                float near = onsp_.VolumetricRadius + onsp_.Near;
                float far  = onsp_.VolumetricRadius + Mathf.Max(near, onsp_.Far + EPS_);

                audioSource_.maxDistance = far;

                CreateRolloffCurve(near, far);
                CreateSpatialCurve(near, far);
            }
        }
        private void SetSpatializer(VRC_SpatialAudioSource obj)
        {
            spatialAudioSource_ = obj;
            audioSource_        = GetComponent <AudioSource>();
            onsp_        = this;
            forceUpdate_ = true;

            UpdateSettings();
        }
Example #5
0
        public static void InitializeAudio(VRC_SpatialAudioSource obj)
        {
            // Why?
            if (!Application.isPlaying)
            {
                return;
            }

            obj.gameObject.AddComponent <CyanEmuSpatialAudioHelper>().SetSpatializer(obj);
        }
Example #6
0
        static void ProcessSpatialAudioSources(AudioSource audioSource)
        {
#if VRC_SDK_VRCSDK2
            VRC_SpatialAudioSource vrcSpatialAudioSource2 = audioSource.gameObject.GetComponent <VRC_SpatialAudioSource>();
            if (vrcSpatialAudioSource2 == null)
            {
                // user has not yet added VRC_SpatialAudioSource (or ONSP)
                // so set up some defaults
                vrcSpatialAudioSource2                      = audioSource.gameObject.AddComponent <VRC_SpatialAudioSource>();
                vrcSpatialAudioSource2.Gain                 = AudioManagerSettings.AvatarAudioMaxGain;
                vrcSpatialAudioSource2.Far                  = AudioManagerSettings.AvatarAudioMaxRange;
                vrcSpatialAudioSource2.Near                 = 0f;
                vrcSpatialAudioSource2.VolumetricRadius     = 0f;
                vrcSpatialAudioSource2.EnableSpatialization = true;
                vrcSpatialAudioSource2.enabled              = true;
                audioSource.spatialize                      = true;
                audioSource.priority              = Mathf.Clamp(audioSource.priority, 200, 255);
                audioSource.bypassEffects         = false;
                audioSource.bypassListenerEffects = false;
                audioSource.spatialBlend          = 1f;
                audioSource.spread = 0;

                // user is allowed to change, but for now put a safe default
                audioSource.maxDistance = AudioManagerSettings.AvatarAudioMaxRange;
                audioSource.minDistance = audioSource.maxDistance / 500f;
                audioSource.rolloffMode = AudioRolloffMode.Logarithmic;
            }
#elif VRC_SDK_VRCSDK3
            VRC.SDK3.Avatars.Components.VRCSpatialAudioSource vrcSpatialAudioSource2 = audioSource.gameObject.GetComponent <VRC.SDK3.Avatars.Components.VRCSpatialAudioSource>();
            if (vrcSpatialAudioSource2 == null)
            {
                // user has not yet added VRC_SpatialAudioSource (or ONSP)
                // so set up some defaults
                vrcSpatialAudioSource2                      = audioSource.gameObject.AddComponent <VRC.SDK3.Avatars.Components.VRCSpatialAudioSource>();
                vrcSpatialAudioSource2.Gain                 = AudioManagerSettings.AvatarAudioMaxGain;
                vrcSpatialAudioSource2.Far                  = AudioManagerSettings.AvatarAudioMaxRange;
                vrcSpatialAudioSource2.Near                 = 0f;
                vrcSpatialAudioSource2.VolumetricRadius     = 0f;
                vrcSpatialAudioSource2.EnableSpatialization = true;
                vrcSpatialAudioSource2.enabled              = true;
                audioSource.spatialize                      = true;
                audioSource.priority              = Mathf.Clamp(audioSource.priority, 200, 255);
                audioSource.bypassEffects         = false;
                audioSource.bypassListenerEffects = false;
                audioSource.spatialBlend          = 1f;
                audioSource.spread = 0;

                // user is allowed to change, but for now put a safe default
                audioSource.maxDistance = AudioManagerSettings.AvatarAudioMaxRange;
                audioSource.minDistance = audioSource.maxDistance / 500f;
                audioSource.rolloffMode = AudioRolloffMode.Logarithmic;
            }
#endif
        }
        public static void InitializeAudio(VRC_SpatialAudioSource obj)
        {
            // Why?
            if (!Application.isPlaying || string.IsNullOrEmpty(obj.gameObject.scene.path))
            {
                return;
            }

            CyanEmuSpatialAudioHelper spatialAudio = obj.GetComponent <CyanEmuSpatialAudioHelper>();

            if (spatialAudio != null)
            {
                DestroyImmediate(spatialAudio);
            }

            spatialAudio = obj.gameObject.AddComponent <CyanEmuSpatialAudioHelper>();
            spatialAudio.SetSpatializer(obj);
        }
        private void UseScriptSettings()
        {
            for (int i = 0; i < AudioSources.Length; i++)
            {
                if (AudioSources[i] != null)
                {
                    AudioSources[i].mute = Mute;
                    // AudioSources[i].bypassListenerEffects = BypassListenerEffects;
                    AudioSources[i].bypassReverbZones = BypassReverbZones;
                    AudioSources[i].playOnAwake       = PlayOnAwake;
                    AudioSources[i].loop = Loop;

                    AudioSources[i].priority      = Priority;
                    AudioSources[i].volume        = Volume;
                    AudioSources[i].pitch         = Pitch;
                    AudioSources[i].panStereo     = StereoPan;
                    AudioSources[i].reverbZoneMix = ReverbZoneMix;
                    AudioSources[i].spatialBlend  = SpatialBlend;
                    AudioSources[i].dopplerLevel  = DopplerLevel;
                    AudioSources[i].spread        = Spread;

                    AudioSources[i].rolloffMode = VolumeRolloff;
                    AudioSources[i].minDistance = MinDistance;
                    AudioSources[i].maxDistance = MaxDistance;

#if NotExposedInUdon
                    VRC_SpatialAudioSource temp = (VRC_SpatialAudioSource)AudioSources[i].gameObject.GetComponent(typeof(VRC_SpatialAudioSource));
                    if (temp != null)
                    {
                        temp.Gain                      = Gain;
                        temp.Far                       = Far;
                        temp.Near                      = Near;
                        temp.VolumetricRadius          = VolumetricRadius;
                        temp.EnableSpatialization      = EnableSpatialization;
                        temp.UseAudioSourceVolumeCurve = AudioSourceVolumeCurve;
                    }
#endif
                }
            }
            UiRefresh();
        }
        /// <summary>
        /// Saves the original settings from the component in element:0.
        /// </summary>
        public void SaveSettingsFromComponent()
        {
            SavedMute = AudioSources[0].mute;
            // SavedBypassListenerEffects = AudioSources[0].bypassListenerEffects;
            SavedBypassReverbZones = AudioSources[0].bypassReverbZones;
            SavedPlayOnAwake       = AudioSources[0].playOnAwake;
            SavedLoop = AudioSources[0].loop;

            SavedPriority  = AudioSources[0].priority;
            SavedVolume    = AudioSources[0].volume;
            SavedPitch     = AudioSources[0].pitch;
            SavedStereoPan = AudioSources[0].panStereo;

            SavedSpatialBlend  = AudioSources[0].spatialBlend;
            SavedReverbZoneMix = AudioSources[0].reverbZoneMix;
            SavedDopplerLevel  = AudioSources[0].dopplerLevel;
            SavedSpread        = AudioSources[0].spread;

            SavedVolumeRolloff = AudioSources[0].rolloffMode;

            SavedMinDistance = AudioSources[0].minDistance;
            SavedMaxDistance = AudioSources[0].maxDistance;

#if NotExposedInUdon
            VRC_SpatialAudioSource temp = (VRC_SpatialAudioSource)AudioSources[0].gameObject.GetComponent(typeof(VRC_SpatialAudioSource));
            if (temp != null)
            {
                SavedGain                   = temp.Gain;
                SavedFar                    = temp.Far;
                SavedNear                   = temp.Near;
                SavedVolumetricRadius       = temp.VolumetricRadius;
                SavedEnableSpatialization   = temp.EnableSpatialization;
                SavedAudioSourceVolumeCurve = temp.UseAudioSourceVolumeCurve;
            }
#endif
        }
        public static IEnumerator EnforceAudioSourceLimitsEnumerator(GameObject currentAvatar, System.Action <AudioSource> onFound)
        {
            if (currentAvatar == null)
            {
                yield break;
            }

            Queue <GameObject> children = new Queue <GameObject>();

            if (currentAvatar != null)
            {
                children.Enqueue(currentAvatar.gameObject);
            }

            while (children.Count > 0)
            {
                if (Time.frameCount > _enforceAudioSourcesFrameNumber)
                {
                    _enforceAudioSourcesFrameNumber        = Time.frameCount;
                    _enforceAudioSourcesProcessedThisFrame = 0;
                }

                if (_enforceAudioSourcesProcessedThisFrame > ENFORCE_AUDIO_SOURCE_GAMEOBJECTS_PER_FRAME)
                {
                    yield return(null);
                }

                Profiler.BeginSample("EnforceAudioSourceLimitsEnumerator");
                _enforceAudioSourcesProcessedThisFrame++;

                GameObject child = children.Dequeue();
                if (child == null)
                {
                    Profiler.EndSample();
                    continue;
                }

                int childCount = child.transform.childCount;
                for (int idx = 0; idx < childCount; ++idx)
                {
                    children.Enqueue(child.transform.GetChild(idx).gameObject);
                }

                #if VRC_CLIENT
                if (child.GetComponent <USpeaker>() != null)
                {
                    Profiler.EndSample();
                    continue;
                }
                #endif

                AudioSource[] sources = child.transform.GetComponents <AudioSource>();
                if (sources != null && sources.Length > 0)
                {
                    AudioSource audioSource = sources[0];
                    if (audioSource == null)
                    {
                        Profiler.EndSample();
                        continue;
                    }

                    VRC_SpatialAudioSource vrcSpatialAudioSource = audioSource.gameObject.GetComponent <VRC_SpatialAudioSource>();

                    #if VRC_CLIENT
                    audioSource.outputAudioMixerGroup = VRCAudioManager.GetAvatarGroup();
                    audioSource.priority = Mathf.Clamp(audioSource.priority, 200, 255);
                    if (vrcSpatialAudioSource != null)
                    {
                        // copy the values into the onsp component
                        var onspAudioSource = audioSource.gameObject.GetOrAddComponent <ONSPAudioSource>();
                        onspAudioSource.Gain                 = vrcSpatialAudioSource.Gain;
                        onspAudioSource.Near                 = vrcSpatialAudioSource.Near;
                        onspAudioSource.Far                  = vrcSpatialAudioSource.Far;
                        onspAudioSource.VolumetricRadius     = vrcSpatialAudioSource.VolumetricRadius;
                        onspAudioSource.EnableSpatialization = vrcSpatialAudioSource.EnableSpatialization;
                        onspAudioSource.UseInvSqr            = !vrcSpatialAudioSource.UseAudioSourceVolumeCurve;
                        if (!vrcSpatialAudioSource.EnableSpatialization)
                        {
                            audioSource.spatialize = false;
                        }
                    }
                    #else
                    // these are SDK only, we rely on AvatarAudioSourceLimiter to enforce
                    // values at runtime

                    #if SUPPORT_DEPRECATED_ONSP
                    ONSPAudioSource[] allOnsp = audioSource.gameObject.GetComponents <ONSPAudioSource>();
                    if (allOnsp != null && allOnsp.Length > 0)
                    {
                        ONSPAudioSource onsp = allOnsp[0];
                        if (vrcSpatialAudioSource == null)
                        {
                            vrcSpatialAudioSource = audioSource.gameObject.AddComponent <VRC_SpatialAudioSource>();
                        }

                        vrcSpatialAudioSource.Gain                      = Mathf.Min(onsp.Gain, VRCSDK2.AudioManagerSettings.AvatarAudioMaxGain);
                        vrcSpatialAudioSource.Far                       = Mathf.Min(onsp.Far, VRCSDK2.AudioManagerSettings.AvatarAudioMaxRange);
                        vrcSpatialAudioSource.VolumetricRadius          = Mathf.Min(onsp.Far, VRCSDK2.AudioManagerSettings.AvatarAudioMaxRange);
                        vrcSpatialAudioSource.Near                      = Mathf.Min(onsp.Near, onsp.Far);
                        vrcSpatialAudioSource.EnableSpatialization      = onsp.EnableSpatialization;
                        vrcSpatialAudioSource.UseAudioSourceVolumeCurve = !onsp.UseInvSqr;

                        Debug.LogWarningFormat("ONSPAudioSource found on {0}. converted to VRC_SpatialAudioSource.", child.name);
                        foreach (var o in allOnsp)
                        {
                            Object.DestroyImmediate(o, true);
                        }
                    }
                    #endif
                    if (vrcSpatialAudioSource == null)
                    {
                        // user has not yet added VRC_SpatialAudioSource (or ONSP)
                        // so set up some defaults
                        vrcSpatialAudioSource                      = audioSource.gameObject.AddComponent <VRC_SpatialAudioSource>();
                        vrcSpatialAudioSource.Gain                 = AudioManagerSettings.AvatarAudioMaxGain;
                        vrcSpatialAudioSource.Far                  = AudioManagerSettings.AvatarAudioMaxRange;
                        vrcSpatialAudioSource.Near                 = 0f;
                        vrcSpatialAudioSource.VolumetricRadius     = 0f;
                        vrcSpatialAudioSource.EnableSpatialization = true;
                        vrcSpatialAudioSource.enabled              = true;
                        audioSource.spatialize                     = true;
                        audioSource.priority              = Mathf.Clamp(audioSource.priority, 200, 255);
                        audioSource.bypassEffects         = false;
                        audioSource.bypassListenerEffects = false;
                        audioSource.spatialBlend          = 1f;
                        audioSource.spread = 0;

                        // user is allowed to change, but for now put a safe default
                        audioSource.maxDistance = AudioManagerSettings.AvatarAudioMaxRange;
                        audioSource.minDistance = audioSource.maxDistance / 500f;
                        audioSource.rolloffMode = AudioRolloffMode.Logarithmic;
                    }
                    #endif //!VRC_CLIENT

                    onFound(audioSource);

                    if (sources.Length > 1)
                    {
                        Debug.LogError("Disabling extra AudioSources on GameObject(" + child.name + "). Only one is allowed per GameObject.");
                        for (int i = 1; i < sources.Length; i++)
                        {
                            if (sources[i] == null)
                            {
                                Profiler.EndSample();
                                continue;
                            }

                            #if VRC_CLIENT
                            sources[i].enabled = false;
                            sources[i].clip    = null;
                            #else
                            ValidationUtils.RemoveComponent(sources[i]);
                            #endif //!VRC_CLIENT
                        }
                    }
                }

                Profiler.EndSample();
            }
        }