Example #1
0
        public void FrameUpdate(bool sourceUpdate, SourceSimulationType sourceSimulationType,
                                ReverbSimulationType reverbSimulationType, PhononStaticListener phononStaticListener, PhononListener phononListener)
        {
            if (sourceUpdate && sourceSimulationType == SourceSimulationType.BakedStaticListener && phononStaticListener != null &&
                phononStaticListener.currentStaticListenerNode != null)
            {
                UpdateEffectName(phononStaticListener.currentStaticListenerNode.GetUniqueIdentifier());
            }

            if (phononListener && phononListener.acceleratedMixing)
            {
                fourierMixingEnabled = true;
            }
            else
            {
                fourierMixingEnabled = false;
            }
        }
Example #2
0
        public void LazyInitialize(BinauralRenderer binauralRenderer, bool reflectionEnabled, bool indirectBinauralEnabled,
                                   RenderingSettings renderingSettings, bool sourceUpdate, SourceSimulationType sourceSimulationType,
                                   string uniqueIdentifier, PhononStaticListener phononStaticListener, ReverbSimulationType reverbSimualtionType,
                                   EnvironmentalRenderer environmentalRenderer)
        {
#if !UNITY_ANDROID
            AudioFormat ambisonicsBinauralFormat = outputFormat;
            ambisonicsBinauralFormat.channelOrder = ChannelOrder.Deinterleaved;

            // Set up propagationPanningEffect
            if (reflectionEnabled && propagationPanningEffect == IntPtr.Zero &&
                binauralRenderer.GetBinauralRenderer() != IntPtr.Zero)
            {
                if (PhononCore.iplCreateAmbisonicsPanningEffect(binauralRenderer.GetBinauralRenderer(), ambisonicsFormat,
                                                                ambisonicsBinauralFormat, ref propagationPanningEffect) != Error.None)
                {
                    Debug.Log("Unable to create Ambisonics panning effect. Please check the log file for details.");
                    return;
                }
            }

            // Set up propagationBinauralEffect
            if (outputFormat.channelLayout == ChannelLayout.Stereo && reflectionEnabled && indirectBinauralEnabled &&
                propagationBinauralEffect == IntPtr.Zero && binauralRenderer.GetBinauralRenderer() != IntPtr.Zero)
            {
                // Create ambisonics based binaural effect for indirect sound if the output format is stereo.
                if (PhononCore.iplCreateAmbisonicsBinauralEffect(binauralRenderer.GetBinauralRenderer(), ambisonicsFormat,
                                                                 ambisonicsBinauralFormat, ref propagationBinauralEffect) != Error.None)
                {
                    Debug.Log("Unable to create propagation binaural effect. Please check the log file for details.");
                    return;
                }
            }

            // Set up propagationAmbisonicsEffect
            if (reflectionEnabled && propagationAmbisonicsEffect == IntPtr.Zero &&
                environmentalRenderer.GetEnvironmentalRenderer() != IntPtr.Zero)
            {
                string effectName = "";

                if (sourceUpdate && sourceSimulationType == SourceSimulationType.BakedStaticSource)
                {
                    effectName = uniqueIdentifier;
                }
                else if (sourceUpdate && sourceSimulationType == SourceSimulationType.BakedStaticListener)
                {
                    if (phononStaticListener == null)
                    {
                        Debug.LogError("No Phonon Static Listener component found.");
                    }
                    else if (phononStaticListener.currentStaticListenerNode == null)
                    {
                        Debug.LogError("Current static listener node is not specified in Phonon Static Listener.");
                    }
                    else
                    {
                        effectName = phononStaticListener.currentStaticListenerNode.GetUniqueIdentifier();
                    }
                }
                else if (!sourceUpdate && reverbSimualtionType == ReverbSimulationType.BakedReverb)
                {
                    effectName = "__reverb__";
                }

                SimulationType simulationMode;
                if (sourceUpdate)
                {
                    simulationMode = (sourceSimulationType == SourceSimulationType.Realtime) ?
                                     SimulationType.Realtime : SimulationType.Baked;
                }
                else
                {
                    simulationMode = (reverbSimualtionType == ReverbSimulationType.RealtimeReverb) ?
                                     SimulationType.Realtime : SimulationType.Baked;
                }

                if (PhononCore.iplCreateConvolutionEffect(environmentalRenderer.GetEnvironmentalRenderer(),
                                                          Common.ConvertString(effectName), simulationMode, inputFormat, ambisonicsFormat,
                                                          ref propagationAmbisonicsEffect) != Error.None)
                {
                    Debug.LogError("Unable to create propagation effect for object");
                }
            }

            if (reflectionEnabled && wetData == null)
            {
                wetData = new float[renderingSettings.frameSize * outputFormat.numSpeakers];
            }

            if (reflectionEnabled && wetAmbisonicsDataMarshal == null)
            {
                wetAmbisonicsDataMarshal = new IntPtr[ambisonicsFormat.numSpeakers];
                for (int i = 0; i < ambisonicsFormat.numSpeakers; ++i)
                {
                    wetAmbisonicsDataMarshal[i] = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(float)) * renderingSettings.frameSize);
                }
            }

            if (reflectionEnabled && wetDataMarshal == null)
            {
                wetDataMarshal = new IntPtr[outputFormat.numSpeakers];
                for (int i = 0; i < outputFormat.numSpeakers; ++i)
                {
                    wetDataMarshal[i] = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(float)) * renderingSettings.frameSize);
                }
            }
#endif
        }